diff --git a/plugins/org.eclipse.wst.common.modulecore/model/componentCore.ecore b/plugins/org.eclipse.wst.common.modulecore/model/componentCore.ecore
index 21a0522..29d6aa3 100644
--- a/plugins/org.eclipse.wst.common.modulecore/model/componentCore.ecore
+++ b/plugins/org.eclipse.wst.common.modulecore/model/componentCore.ecore
@@ -22,6 +22,8 @@
         eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString" defaultValueLiteral=""/>
     <eStructuralFeatures xsi:type="ecore:EReference" name="component" unique="false"
         lowerBound="1" eType="#//WorkbenchComponent" eOpposite="#//WorkbenchComponent/resources"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="resourceType" lowerBound="1"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString" defaultValueLiteral=""/>
   </eClassifiers>
   <eClassifiers xsi:type="ecore:EDataType" name="IPath" instanceClassName="org.eclipse.core.runtime.IPath">
     <eAnnotations source="keywords">
diff --git a/plugins/org.eclipse.wst.common.modulecore/model/componentCore.emx b/plugins/org.eclipse.wst.common.modulecore/model/componentCore.emx
index 20fc1be..91c48c8 100644
--- a/plugins/org.eclipse.wst.common.modulecore/model/componentCore.emx
+++ b/plugins/org.eclipse.wst.common.modulecore/model/componentCore.emx
@@ -523,6 +523,9 @@
       <upperValue xmi:type="uml:LiteralUnlimitedNatural" xmi:id="_kOVl5JTYEdmy2onHYKlABg" value="1"/>
       <lowerValue xmi:type="uml:LiteralInteger" xmi:id="_kOVl45TYEdmy2onHYKlABg" value="1"/>
     </ownedAttribute>
+    <ownedAttribute xmi:id="_jw5GQKV-EdmoYeO-WR9aDg" name="resourceType">
+      <type xmi:type="uml:PrimitiveType" href="pathmap://UML2_LIBRARIES/UML2PrimitiveTypes.library.uml2#_IXlH8a86EdieaYgxtVWN8Q"/>
+    </ownedAttribute>
   </ownedMember>
   <ownedMember xmi:type="uml:Class" xmi:id="_3A0B2474025F41EC1D5103E2" name="ComponentType">
     <ownedAttribute xmi:id="_3A0B2474025F41EC21340357" name="componentTypeId">
diff --git a/plugins/org.eclipse.wst.common.modulecore/model/componentCore2.genmodel b/plugins/org.eclipse.wst.common.modulecore/model/componentCore.genmodel
similarity index 92%
rename from plugins/org.eclipse.wst.common.modulecore/model/componentCore2.genmodel
rename to plugins/org.eclipse.wst.common.modulecore/model/componentCore.genmodel
index ae96db8..4f6460b 100644
--- a/plugins/org.eclipse.wst.common.modulecore/model/componentCore2.genmodel
+++ b/plugins/org.eclipse.wst.common.modulecore/model/componentCore.genmodel
@@ -3,8 +3,8 @@
     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" modelDirectory="/org.eclipse.wst.common.modulecore/modulecore-src"
     editDirectory="/org.eclipse.wst.common.modulecore.edit/src" editorDirectory="/org.eclipse.wst.common.modulecore.editor/src"
-    modelPluginID="org.eclipse.wst.common.modulecore" runtimeJar="true" modelName="ComponentCore2"
-    editPluginClass="componentcore.provider.ComponentCore2EditPlugin" editorPluginClass="componentcore.presentation.ComponentCore2EditorPlugin"
+    modelPluginID="org.eclipse.wst.common.modulecore" runtimeJar="true" modelName="ComponentCore"
+    editPluginClass="componentcore.provider.ComponentCoreEditPlugin" editorPluginClass="componentcore.presentation.ComponentCoreEditorPlugin"
     runtimeCompatibility="false">
   <foreignModel>componentCore.ecore</foreignModel>
   <genPackages prefix="Componentcore" basePackage="org.eclipse.wst.common.componentcore.internal"
@@ -26,6 +26,7 @@
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute componentCore.ecore#//ComponentResource/runtimePath"/>
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute componentCore.ecore#//ComponentResource/exclusions"/>
       <genFeatures property="None" notify="false" createChild="false" ecoreFeature="ecore:EReference componentCore.ecore#//ComponentResource/component"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute componentCore.ecore#//ComponentResource/resourceType"/>
     </genClasses>
     <genClasses ecoreClass="componentCore.ecore#//ComponentType">
       <genFeatures createChild="false" ecoreFeature="ecore:EAttribute componentCore.ecore#//ComponentType/componentTypeId"/>
diff --git a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/StructureEdit.java b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/StructureEdit.java
index 122e1d5..2b16288 100644
--- a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/StructureEdit.java
+++ b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/StructureEdit.java
@@ -176,8 +176,11 @@
 	 *             If the supplied module URI is invalid or unresolveable.
 	 */
 	public static IProject getContainingProject(WorkbenchComponent aComponent) {	
-		IProject project = ProjectUtilities.getProject(aComponent);
-		if (project != null && project.isAccessible())
+		String projectName = aComponent.getHandle().segment(ModuleURIUtil.ModuleURI.PROJECT_NAME_INDX);
+		if (projectName == null || projectName.length() == 0)
+			return null;
+		IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
+		if (project.isAccessible())
 			return project;
 		return null;
 	}
diff --git a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/ComponentResource.java b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/ComponentResource.java
index 2c65e00..ef99b8f 100644
--- a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/ComponentResource.java
+++ b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/ComponentResource.java
@@ -1,7 +1,7 @@
 /**
  * <copyright></copyright>
  * 
- * $Id: ComponentResource.java,v 1.1 2005/04/04 07:05:00 cbridgha Exp $
+ * $Id: ComponentResource.java,v 1.2 2005/04/05 03:35:37 cbridgha Exp $
  */
 package org.eclipse.wst.common.componentcore.internal;
 
@@ -33,6 +33,7 @@
  *   <li>{@link org.eclipse.wst.common.componentcore.internal.ComponentResource#getRuntimePath <em>Runtime Path</em>}</li>
  *   <li>{@link org.eclipse.wst.common.componentcore.internal.ComponentResource#getExclusions <em>Exclusions</em>}</li>
  *   <li>{@link org.eclipse.wst.common.componentcore.internal.ComponentResource#getComponent <em>Component</em>}</li>
+ *   <li>{@link org.eclipse.wst.common.componentcore.internal.ComponentResource#getResourceType <em>Resource Type</em>}</li>
  * </ul>
  * </p>
  *
@@ -138,4 +139,31 @@
 	 */
 	void setComponent(WorkbenchComponent value);
 
+	/**
+	 * Returns the value of the '<em><b>Resource Type</b></em>' attribute.
+	 * The default value is <code>""</code>.
+	 * <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Resource Type</em>' attribute isn't clear,
+	 * there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * @return the value of the '<em>Resource Type</em>' attribute.
+	 * @see #setResourceType(String)
+	 * @see org.eclipse.wst.common.componentcore.internal.ComponentcorePackage#getComponentResource_ResourceType()
+	 * @model default="" required="true"
+	 * @generated
+	 */
+	String getResourceType();
+
+	/**
+	 * Sets the value of the '{@link org.eclipse.wst.common.componentcore.internal.ComponentResource#getResourceType <em>Resource Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param value the new value of the '<em>Resource Type</em>' attribute.
+	 * @see #getResourceType()
+	 * @generated
+	 */
+	void setResourceType(String value);
+
 } // ComponentResource
diff --git a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/ComponentcorePackage.java b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/ComponentcorePackage.java
index 68f55ef..1570430 100644
--- a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/ComponentcorePackage.java
+++ b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/ComponentcorePackage.java
@@ -2,7 +2,7 @@
  * <copyright>
  * </copyright>
  *
- * $Id: ComponentcorePackage.java,v 1.1 2005/04/04 07:05:00 cbridgha Exp $
+ * $Id: ComponentcorePackage.java,v 1.2 2005/04/05 03:35:37 cbridgha Exp $
  */
 package org.eclipse.wst.common.componentcore.internal;
 
@@ -162,13 +162,22 @@
 	int COMPONENT_RESOURCE__COMPONENT = 3;
 
 	/**
+	 * The feature id for the '<em><b>Resource Type</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int COMPONENT_RESOURCE__RESOURCE_TYPE = 4;
+
+	/**
 	 * The number of structural features of the the '<em>Component Resource</em>' class.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
 	 * @generated
 	 * @ordered
 	 */
-	int COMPONENT_RESOURCE_FEATURE_COUNT = 4;
+	int COMPONENT_RESOURCE_FEATURE_COUNT = 5;
 
 	/**
 	 * The meta object id for the '{@link org.eclipse.wst.common.componentcore.internal.impl.ComponentTypeImpl <em>Component Type</em>}' class.
@@ -485,6 +494,17 @@
 	EReference getComponentResource_Component();
 
 	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.wst.common.componentcore.internal.ComponentResource#getResourceType <em>Resource Type</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Resource Type</em>'.
+	 * @see org.eclipse.wst.common.componentcore.internal.ComponentResource#getResourceType()
+	 * @see #getComponentResource()
+	 * @generated
+	 */
+	EAttribute getComponentResource_ResourceType();
+
+	/**
 	 * Returns the meta object for class '{@link org.eclipse.wst.common.componentcore.internal.ComponentType <em>Component Type</em>}'.
 	 * <!-- begin-user-doc -->
 	 * <!-- end-user-doc -->
diff --git a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/WorkbenchComponent.java b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/WorkbenchComponent.java
index 676ddf8..7844879 100644
--- a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/WorkbenchComponent.java
+++ b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/WorkbenchComponent.java
@@ -121,7 +121,7 @@
 	 * @generated
 	 */
 	EList getReferencedComponents();
-	
+
 	URI getHandle();
 
 	ComponentResource[] findWorkbenchModuleResourceByDeployPath(URI aDeployPath);
diff --git a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/impl/ComponentResourceImpl.java b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/impl/ComponentResourceImpl.java
index 446d8c1..8aa7232 100644
--- a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/impl/ComponentResourceImpl.java
+++ b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/impl/ComponentResourceImpl.java
@@ -2,7 +2,7 @@
  * <copyright>
  * </copyright>
  *
- * $Id: ComponentResourceImpl.java,v 1.1 2005/04/04 07:04:59 cbridgha Exp $
+ * $Id: ComponentResourceImpl.java,v 1.2 2005/04/05 03:35:37 cbridgha Exp $
  */
 package org.eclipse.wst.common.componentcore.internal.impl;
 
@@ -34,6 +34,7 @@
  *   <li>{@link org.eclipse.wst.common.componentcore.internal.impl.ComponentResourceImpl#getRuntimePath <em>Runtime Path</em>}</li>
  *   <li>{@link org.eclipse.wst.common.componentcore.internal.impl.ComponentResourceImpl#getExclusions <em>Exclusions</em>}</li>
  *   <li>{@link org.eclipse.wst.common.componentcore.internal.impl.ComponentResourceImpl#getComponent <em>Component</em>}</li>
+ *   <li>{@link org.eclipse.wst.common.componentcore.internal.impl.ComponentResourceImpl#getResourceType <em>Resource Type</em>}</li>
  * </ul>
  * </p>
  *
@@ -90,6 +91,26 @@
 	 */
 	protected EList exclusions = null;
 	
+	/**
+	 * The default value of the '{@link #getResourceType() <em>Resource Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getResourceType()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String RESOURCE_TYPE_EDEFAULT = "";
+
+	/**
+	 * The cached value of the '{@link #getResourceType() <em>Resource Type</em>}' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #getResourceType()
+	 * @generated
+	 * @ordered
+	 */
+	protected String resourceType = RESOURCE_TYPE_EDEFAULT;
+
 	protected static final int VIRTUAL = 0;
 	protected static final int PERSISTED = 1;
 	
@@ -203,6 +224,27 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public String getResourceType() {
+		return resourceType;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void setResourceType(String newResourceType) {
+		String oldResourceType = resourceType;
+		resourceType = newResourceType;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, ComponentcorePackage.COMPONENT_RESOURCE__RESOURCE_TYPE, oldResourceType, resourceType));
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public NotificationChain eInverseAdd(InternalEObject otherEnd, int featureID, Class baseClass, NotificationChain msgs) {
 		if (featureID >= 0) {
 			switch (eDerivedStructuralFeatureID(featureID, baseClass)) {
@@ -268,6 +310,8 @@
 				return getExclusions();
 			case ComponentcorePackage.COMPONENT_RESOURCE__COMPONENT:
 				return getComponent();
+			case ComponentcorePackage.COMPONENT_RESOURCE__RESOURCE_TYPE:
+				return getResourceType();
 		}
 		return eDynamicGet(eFeature, resolve);
 	}
@@ -292,6 +336,9 @@
 			case ComponentcorePackage.COMPONENT_RESOURCE__COMPONENT:
 				setComponent((WorkbenchComponent)newValue);
 				return;
+			case ComponentcorePackage.COMPONENT_RESOURCE__RESOURCE_TYPE:
+				setResourceType((String)newValue);
+				return;
 		}
 		eDynamicSet(eFeature, newValue);
 	}
@@ -315,6 +362,9 @@
 			case ComponentcorePackage.COMPONENT_RESOURCE__COMPONENT:
 				setComponent((WorkbenchComponent)null);
 				return;
+			case ComponentcorePackage.COMPONENT_RESOURCE__RESOURCE_TYPE:
+				setResourceType(RESOURCE_TYPE_EDEFAULT);
+				return;
 		}
 		eDynamicUnset(eFeature);
 	}
@@ -334,6 +384,8 @@
 				return exclusions != null && !exclusions.isEmpty();
 			case ComponentcorePackage.COMPONENT_RESOURCE__COMPONENT:
 				return getComponent() != null;
+			case ComponentcorePackage.COMPONENT_RESOURCE__RESOURCE_TYPE:
+				return RESOURCE_TYPE_EDEFAULT == null ? resourceType != null : !RESOURCE_TYPE_EDEFAULT.equals(resourceType);
 		}
 		return eDynamicIsSet(eFeature);
 	}
@@ -353,6 +405,8 @@
 		result.append(runtimePath);
 		result.append(", exclusions: ");
 		result.append(exclusions);
+		result.append(", resourceType: ");
+		result.append(resourceType);
 		result.append(')');
 		return result.toString();
 	}
diff --git a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/impl/ComponentcorePackageImpl.java b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/impl/ComponentcorePackageImpl.java
index 4cf16b7..25d2d40 100644
--- a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/impl/ComponentcorePackageImpl.java
+++ b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/impl/ComponentcorePackageImpl.java
@@ -2,7 +2,7 @@
  * <copyright>
  * </copyright>
  *
- * $Id: ComponentcorePackageImpl.java,v 1.1 2005/04/04 07:04:59 cbridgha Exp $
+ * $Id: ComponentcorePackageImpl.java,v 1.2 2005/04/05 03:35:37 cbridgha Exp $
  */
 package org.eclipse.wst.common.componentcore.internal.impl;
 
@@ -260,6 +260,15 @@
 	 * <!-- end-user-doc -->
 	 * @generated
 	 */
+	public EAttribute getComponentResource_ResourceType() {
+		return (EAttribute)componentResourceEClass.getEStructuralFeatures().get(4);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
 	public EClass getComponentType() {
 		return componentTypeEClass;
 	}
@@ -456,6 +465,7 @@
 		createEAttribute(componentResourceEClass, COMPONENT_RESOURCE__RUNTIME_PATH);
 		createEAttribute(componentResourceEClass, COMPONENT_RESOURCE__EXCLUSIONS);
 		createEReference(componentResourceEClass, COMPONENT_RESOURCE__COMPONENT);
+		createEAttribute(componentResourceEClass, COMPONENT_RESOURCE__RESOURCE_TYPE);
 
 		componentTypeEClass = createEClass(COMPONENT_TYPE);
 		createEAttribute(componentTypeEClass, COMPONENT_TYPE__COMPONENT_TYPE_ID);
@@ -521,6 +531,7 @@
 		initEAttribute(getComponentResource_RuntimePath(), this.getIPath(), "runtimePath", null, 1, 1, ComponentResource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEAttribute(getComponentResource_Exclusions(), ecorePackage.getEString(), "exclusions", "", 0, -1, ComponentResource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
 		initEReference(getComponentResource_Component(), this.getWorkbenchComponent(), this.getWorkbenchComponent_Resources(), "component", null, 1, 1, ComponentResource.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_COMPOSITE, !IS_RESOLVE_PROXIES, !IS_UNSETTABLE, !IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getComponentResource_ResourceType(), ecorePackage.getEString(), "resourceType", "", 1, 1, ComponentResource.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);
 		initEAttribute(getComponentType_ComponentTypeId(), ecorePackage.getEString(), "componentTypeId", "", 1, 1, ComponentType.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
diff --git a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/resources/VirtualReference.java b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/resources/VirtualReference.java
new file mode 100644
index 0000000..65cf376
--- /dev/null
+++ b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/resources/VirtualReference.java
@@ -0,0 +1,60 @@
+/*******************************************************************************
+ * Copyright (c) 2003, 2004 IBM Corporation and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.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.wst.common.componentcore.internal.resources;
+
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.wst.common.componentcore.resources.IVirtualComponent;
+import org.eclipse.wst.common.componentcore.resources.IVirtualReference;
+
+public class VirtualReference implements IVirtualReference {
+
+	public void create(int updateFlags, IProgressMonitor aMonitor) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public void setRuntimePath(IPath aRuntimePath) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public IPath getRuntimePath() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public void setDependencyType(int aDependencyType) {
+		// TODO Auto-generated method stub
+
+	}
+
+	public int getDependencyType() {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	public boolean exists() {
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	public IVirtualComponent getEnclosingComponent() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	public IVirtualComponent getReferencedComponent() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+}
diff --git a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/resources/VirtualResource.java b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/resources/VirtualResource.java
index df28ee3..f270021 100644
--- a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/resources/VirtualResource.java
+++ b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/internal/resources/VirtualResource.java
@@ -16,8 +16,6 @@
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
-import org.eclipse.core.resources.IResourceProxyVisitor;
-import org.eclipse.core.resources.IResourceVisitor;
 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.IPath;
 import org.eclipse.core.runtime.IProgressMonitor;
@@ -51,38 +49,7 @@
 	
 	protected VirtualResource(IProject aProject, String aComponentName, IPath aRuntimePath) {
 		this(ComponentHandle.create(aProject, aComponentName), aRuntimePath);		
-	}	
-
-	public void accept(IResourceProxyVisitor visitor, int memberFlags) throws CoreException {
-		throw new UnsupportedOperationException("Method not supported"); //$NON-NLS-1$
-
-	}
-
-	public void accept(IResourceVisitor visitor) throws CoreException {
-		throw new UnsupportedOperationException("Method not supported"); //$NON-NLS-1$
-
-	}
-
-	public void accept(IResourceVisitor visitor, int depth, boolean includePhantoms) throws CoreException {
-		throw new UnsupportedOperationException("Method not supported"); //$NON-NLS-1$
-
-	}
-
-	public void accept(IResourceVisitor visitor, int depth, int memberFlags) throws CoreException {
-		throw new UnsupportedOperationException("Method not supported"); //$NON-NLS-1$
-
-	}   
-	
-	public void delete(boolean force, IProgressMonitor monitor) throws CoreException {
-		delete(force ? IResource.FORCE : IResource.NONE, monitor);
-	}
-
-	public void delete(boolean force, boolean keepHistory, IProgressMonitor monitor) throws CoreException {
-		int updateFlags = force ? IResource.FORCE : IResource.NONE;
-		updateFlags |= keepHistory ? IResource.KEEP_HISTORY : IResource.NONE;
-		delete(updateFlags, monitor);
-	}
-
+	}	 
 
 	public void delete(int updateFlags, IProgressMonitor monitor) throws CoreException {
 		
diff --git a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/resources/IVirtualReference.java b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/resources/IVirtualReference.java
index dbe2183..a0416e7 100644
--- a/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/resources/IVirtualReference.java
+++ b/plugins/org.eclipse.wst.common.modulecore/modulecore-src/org/eclipse/wst/common/componentcore/resources/IVirtualReference.java
@@ -17,6 +17,8 @@
 	
 	public void create(int updateFlags, IProgressMonitor aMonitor);
 	
+	public boolean exists();
+	
 	public void setRuntimePath(IPath aRuntimePath);
 	
 	public IPath getRuntimePath();
@@ -25,6 +27,8 @@
 	
 	public int getDependencyType();
 	
+	public IVirtualComponent getEnclosingComponent();
 	
+	public IVirtualComponent getReferencedComponent();
 
 }
