diff --git a/ipojo/core/pom.xml b/ipojo/core/pom.xml
index 8debd71..d5044a0 100644
--- a/ipojo/core/pom.xml
+++ b/ipojo/core/pom.xml
@@ -6,9 +6,9 @@
 	to you under the Apache License, Version 2.0 (the
 	"License"); you may not use this file except in compliance
 	with the License.  You may obtain a copy of the License at
-	
+
 	http://www.apache.org/licenses/LICENSE-2.0
-	
+
 	Unless required by applicable law or agreed to in writing,
 	software distributed under the License is distributed on an
 	"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
@@ -29,11 +29,11 @@
 	<artifactId>org.apache.felix.ipojo</artifactId>
 	<groupId>org.apache.felix</groupId>
 	<version>1.3.0-SNAPSHOT</version>
-	
+
 	<properties>
-		<ipojo.package.version>1.3.0</ipojo.package.version>
+		<ipojo.package.version>1.4.0</ipojo.package.version>
 	</properties>
-	
+
 	<dependencies>
 		<dependency>
 			<groupId>org.apache.felix</groupId>
@@ -48,7 +48,7 @@
 		<dependency>
 			<groupId>org.apache.felix</groupId>
 			<artifactId>org.apache.felix.ipojo.metadata</artifactId>
-			<version>1.3.0-SNAPSHOT</version>
+			<version>${pom.version}</version>
 		</dependency>
 		<dependency>
 			<groupId>asm</groupId>
@@ -75,28 +75,28 @@
 						<Bundle-Vendor> The Apache Software Foundation </Bundle-Vendor>
 						<Bundle-SymbolicName>org.apache.felix.ipojo;singleton:=true</Bundle-SymbolicName>
 						<Bundle-Description> iPOJO Core Framework </Bundle-Description>
-						<Bundle-Activator> org.apache.felix.ipojo.Extender 
+						<Bundle-Activator> org.apache.felix.ipojo.Extender
 						</Bundle-Activator>
 						<Bundle-DocURL>
-							http://felix.apache.org/site/apache-felix-ipojo.html 
+							http://felix.apache.org/site/apache-felix-ipojo.html
 						</Bundle-DocURL>
 						<IPOJO-Extension>
 							component:org.apache.felix.ipojo.ComponentFactory,
-							handler:org.apache.felix.ipojo.HandlerManagerFactory 
+							handler:org.apache.felix.ipojo.HandlerManagerFactory
 						</IPOJO-Extension>
-						<Import-Package> 
-							org.osgi.framework;version=1.3, <!-- To support KF 2 --> 
+						<Import-Package>
+							org.osgi.framework;version=1.3, <!-- To support KF 2 -->
 							org.osgi.service.cm,
-							org.osgi.service.log, 
+							org.osgi.service.log,
 							!net.sourceforge.cobertura.* <!--  To support code coverage -->
 						</Import-Package>
-						<Private-Package> 
+						<Private-Package>
 							org.apache.felix.ipojo.handlers.architecture,
 							org.apache.felix.ipojo.handlers.lifecycle.callback,
 							org.apache.felix.ipojo.handlers.lifecycle.controller,
 							org.objectweb.asm
 						</Private-Package>
-						<Export-Package> 
+						<Export-Package>
 							org.apache.felix.ipojo; version="${ipojo.package.version}",
 							org.apache.felix.ipojo.metadata; version="${ipojo.package.version}",
 							org.apache.felix.ipojo.architecture; version="${ipojo.package.version}",
@@ -106,12 +106,12 @@
 							org.apache.felix.ipojo.handlers.providedservice; version="${ipojo.package.version}",
 							org.apache.felix.ipojo.handlers.configuration; version="${ipojo.package.version}",
 							org.apache.felix.ipojo.context; version="${ipojo.package.version}",
-							org.osgi.service.cm, 
-							org.osgi.service.log 
+							org.osgi.service.cm,
+							org.osgi.service.log
 						</Export-Package>
-						<Include-Resource> 
+						<Include-Resource>
 							META-INF/LICENCE=LICENSE,
-							META-INF/NOTICE=NOTICE 
+							META-INF/NOTICE=NOTICE
 						</Include-Resource>
 						<_donotcopy> (CVS|.svn|.+.bak|~.+|metadata.xml) </_donotcopy>
 					</instructions>
@@ -120,7 +120,7 @@
 			<plugin>
 				<groupId>org.apache.felix</groupId>
 				<artifactId>maven-ipojo-plugin</artifactId>
-				<version>1.3.0-SNAPSHOT</version>
+				<version>${pom.version}</version>
 				<executions>
 					<execution>
 						<goals>
diff --git a/ipojo/core/src/main/resources/core.xsd b/ipojo/core/src/main/resources/core.xsd
index 3099b8e..e29f8a3 100644
--- a/ipojo/core/src/main/resources/core.xsd
+++ b/ipojo/core/src/main/resources/core.xsd
@@ -6,9 +6,9 @@
 	to you under the Apache License, Version 2.0 (the
 	"License"); you may not use this file except in compliance
 	with the License.  You may obtain a copy of the License at
-	
+
 	http://www.apache.org/licenses/LICENSE-2.0
-	
+
 	Unless required by applicable law or agreed to in writing,
 	software distributed under the License is distributed on an
 	"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
@@ -107,6 +107,11 @@
                     	<xs:documentation>The (unique) name of the instance.</xs:documentation>
                     </xs:annotation>
 				</xs:attribute>
+				<xs:attribute name="version" type="xs:string" use="optional">
+                    <xs:annotation>
+                    	<xs:documentation>The version of the factory to use.</xs:documentation>
+                    </xs:annotation>
+				</xs:attribute>
 			</xs:extension>
 		</xs:complexContent>
 	</xs:complexType>
@@ -201,6 +206,10 @@
 			<xs:annotation>
 				<xs:documentation>Factory method called to create POJO objects instead of the constructor. The specified method must be a static method of the implementation class returning an instance of this implementation class. The factory method can receive the bundle context in argument.</xs:documentation>
 			</xs:annotation></xs:attribute>
+		<xs:attribute name="version" type="xs:string" use="optional">
+			<xs:annotation>
+				<xs:documentation>Set the version of this component type</xs:documentation>
+			</xs:annotation></xs:attribute>
 	</xs:complexType>
 	<xs:complexType name="RequiresType">
         <xs:annotation>
@@ -216,14 +225,14 @@
                         </xs:annotation>
 					</xs:element>
 				</xs:sequence>
-				
+
 				<xs:attribute name="interface" type="xs:string"
 				    use="prohibited">
                     <xs:annotation>
                     	<xs:documentation>The interface describing the required service type. This attribute is needed only when using aggregate dependencies with field injection and when the type of this field is a list, vector, collection and set. This attribute is deprecated, use 'specification'.</xs:documentation>
                     </xs:annotation>
 				</xs:attribute>
-				
+
 				<xs:attribute name="field" type="xs:string"
 					use="optional">
                     <xs:annotation>
@@ -251,7 +260,7 @@
                     	<xs:documentation>Specific service provider. The dependency can only be fulfilled by the component with the matching name, or by the service with a matching PID.</xs:documentation>
                     </xs:annotation>
 				</xs:attribute>
-				
+
 				<xs:attribute name="scope" use="optional">
 					<xs:simpleType>
 						<xs:restriction base="xs:string">
@@ -413,8 +422,12 @@
 			<xs:annotation>
 				<xs:documentation>Unique identifier used to reconfigure components properties (via  Managed Services) with the Configuration Admin.</xs:documentation>
 			</xs:annotation></xs:attribute>
+		<xs:attribute name="updated" type="xs:string" use="optional">
+			<xs:annotation>
+				<xs:documentation>Method called when a reconfiguration is done</xs:documentation>
+			</xs:annotation></xs:attribute>
 	</xs:complexType>
-	
+
 	<xs:complexType name="ServiceDependencyType">
 	    <xs:attribute name="specification" type="xs:string" use="optional">
 	    	<xs:annotation>
