<persistence xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence persistence_1_0.xsd"
	version="1.0">
	<persistence-unit name="sample" 
		transaction-type="RESOURCE_LOCAL">
		<provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
		<class>org.eclipse.osbp.runtime.web.sample.entities.BaseUUID</class>
		<class>org.eclipse.osbp.runtime.web.sample.entities.Person</class>
		<class>org.eclipse.osbp.runtime.web.sample.entities.Address</class>
		<class>org.eclipse.osbp.runtime.web.sample.entities.Country</class>
	
		<exclude-unlisted-classes>true</exclude-unlisted-classes>
	</persistence-unit>
</persistence>
