diff --git a/ipojo/core/src/main/resources/core.xsd b/ipojo/core/src/main/resources/core.xsd
index 9bb7014..3099b8e 100644
--- a/ipojo/core/src/main/resources/core.xsd
+++ b/ipojo/core/src/main/resources/core.xsd
@@ -319,9 +319,13 @@
 					<xs:documentation>List of service specific properties.</xs:documentation>
 				</xs:annotation></xs:element>
 		</xs:sequence>
-		<xs:attribute name="interface" type="xs:string" use="optional">
+		<xs:attribute name="interface" type="xs:string" use="prohibited">
 			<xs:annotation>
-				<xs:documentation>The list of interfaces of the service to expose. By default, all interfaces implemented by the component implementation class are published.</xs:documentation>
+				<xs:documentation>Deprecated attribute, use 'specifications' instead of 'interface'</xs:documentation>
+			</xs:annotation></xs:attribute>
+		<xs:attribute name="specifications" type="xs:string" use="optional">
+			<xs:annotation>
+				<xs:documentation>The list of service specifications (i.e. interfaces) to expose. By default, all interfaces implemented by the component implementation class are published.</xs:documentation>
 			</xs:annotation></xs:attribute>
 		<xs:attribute name="factory" type="xs:string" use="prohibited">
 			<xs:annotation>
