diff --git a/pom.xml b/pom.xml
index 9d09eaf..4ab3f07 100644
--- a/pom.xml
+++ b/pom.xml
@@ -6,24 +6,29 @@
 
   <groupId>net.sf.ehcache</groupId>
   <artifactId>sizeofengine-hibernate</artifactId>
-  <version>0.9.0</version>
+  <version>0.9.1-SNAPSHOT</version>
+
+  <properties>
+    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    <java.build.version>1.8</java.build.version>
+  </properties>
 
   <dependencies>
     <dependency>
-      <groupId>net.sf.ehcache</groupId>
-      <artifactId>ehcache</artifactId>
-      <version>2.8.0</version>
+      <groupId>net.sf.ehcache.internal</groupId>
+      <artifactId>ehcache-core</artifactId>
+      <version>2.10.6</version>
       <scope>provided</scope>
     </dependency>
     <dependency>
-      <groupId>net.sf.ehcache</groupId>
-      <artifactId>sizeofengine</artifactId>
-      <version>0.1.0</version>
+      <groupId>org.ehcache</groupId>
+      <artifactId>sizeof</artifactId>
+      <version>0.2.0</version>
     </dependency>
     <dependency>
       <groupId>org.hibernate</groupId>
       <artifactId>hibernate-core</artifactId>
-      <version>4.2.8.Final</version>
+      <version>5.2.18.Final</version>
       <scope>provided</scope>
     </dependency>
     <dependency>
@@ -34,5 +39,19 @@
     </dependency>
   </dependencies>
 
+  <build>
+    <plugins>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.8.1</version>
+        <configuration>
+          <source>${java.build.version}</source>
+          <target>${java.build.version}</target>
+        </configuration>
+      </plugin>
+
+    </plugins>
+  </build>
 
 </project>
diff --git a/src/main/java/net/sf/ehcache/sizeofengine/hibernate/HibernateFilterConfigurator.java b/src/main/java/net/sf/ehcache/sizeofengine/hibernate/HibernateFilterConfigurator.java
index 6a3cd78..ba53915 100644
--- a/src/main/java/net/sf/ehcache/sizeofengine/hibernate/HibernateFilterConfigurator.java
+++ b/src/main/java/net/sf/ehcache/sizeofengine/hibernate/HibernateFilterConfigurator.java
@@ -1,7 +1,7 @@
 package net.sf.ehcache.sizeofengine.hibernate;
 
-import net.sf.ehcache.sizeofengine.Filter;
-import net.sf.ehcache.sizeofengine.FilterConfigurator;
+import org.ehcache.sizeof.Filter;
+import org.ehcache.sizeof.FilterConfigurator;
 import org.hibernate.Session;
 import org.hibernate.cache.spi.QueryKey;
 import org.hibernate.engine.spi.SessionImplementor;
@@ -33,7 +33,7 @@ public void configure(final Filter filter) {
   }
 
   private static Set<Field> getAllFields() {
-    Set<Field> fields = new HashSet<Field>();
+    Set<Field> fields = new HashSet<>();
     fields.add(getField(QueryKey.class, "positionalParameterTypes"));
     fields.add(getField(AbstractLazyInitializer.class, "entityName"));
     fields.add(getField(BasicLazyInitializer.class, "persistentClass"));
diff --git a/src/main/resources/META-INF/services/net.sf.ehcache.sizeofengine.FilterConfigurator b/src/main/resources/META-INF/services/org.ehcache.sizeof.FilterConfigurator
similarity index 100%
rename from src/main/resources/META-INF/services/net.sf.ehcache.sizeofengine.FilterConfigurator
rename to src/main/resources/META-INF/services/org.ehcache.sizeof.FilterConfigurator
diff --git a/src/test/java/net/sf/ehcache/sizeofengine/hibernate/HibernateFilterConfiguratorTest.java b/src/test/java/net/sf/ehcache/sizeofengine/hibernate/HibernateFilterConfiguratorTest.java
index 30c94c7..5edbe3e 100644
--- a/src/test/java/net/sf/ehcache/sizeofengine/hibernate/HibernateFilterConfiguratorTest.java
+++ b/src/test/java/net/sf/ehcache/sizeofengine/hibernate/HibernateFilterConfiguratorTest.java
@@ -3,56 +3,37 @@
 import net.sf.ehcache.pool.SizeOfEngine;
 import net.sf.ehcache.pool.SizeOfEngineLoader;
 import net.sf.ehcache.pool.impl.DefaultSizeOfEngine;
-import org.hibernate.CacheMode;
-import org.hibernate.Criteria;
-import org.hibernate.Filter;
-import org.hibernate.FlushMode;
-import org.hibernate.HibernateException;
-import org.hibernate.IdentifierLoadAccess;
-import org.hibernate.Interceptor;
-import org.hibernate.LobHelper;
-import org.hibernate.LockMode;
-import org.hibernate.LockOptions;
-import org.hibernate.NaturalIdLoadAccess;
-import org.hibernate.Query;
-import org.hibernate.ReplicationMode;
-import org.hibernate.SQLQuery;
-import org.hibernate.ScrollMode;
-import org.hibernate.ScrollableResults;
-import org.hibernate.Session;
-import org.hibernate.SessionEventListener;
-import org.hibernate.SessionFactory;
-import org.hibernate.SharedSessionBuilder;
-import org.hibernate.SimpleNaturalIdLoadAccess;
-import org.hibernate.Transaction;
-import org.hibernate.TypeHelper;
-import org.hibernate.UnknownProfileException;
-import org.hibernate.cache.spi.CacheKey;
+import org.hibernate.*;
 import org.hibernate.collection.spi.PersistentCollection;
-import org.hibernate.engine.jdbc.spi.JdbcConnectionAccess;
+import org.hibernate.engine.jdbc.LobCreator;
+import org.hibernate.engine.jdbc.connections.spi.JdbcConnectionAccess;
+import org.hibernate.engine.jdbc.spi.JdbcCoordinator;
+import org.hibernate.engine.jdbc.spi.JdbcServices;
 import org.hibernate.engine.query.spi.sql.NativeSQLQuerySpecification;
-import org.hibernate.engine.spi.EntityKey;
-import org.hibernate.engine.spi.LoadQueryInfluencers;
+import org.hibernate.engine.spi.*;
 import org.hibernate.engine.spi.PersistenceContext;
-import org.hibernate.engine.spi.QueryParameters;
-import org.hibernate.engine.spi.SessionEventListenerManager;
-import org.hibernate.engine.spi.SessionFactoryImplementor;
-import org.hibernate.engine.spi.SessionImplementor;
-import org.hibernate.engine.transaction.spi.TransactionCoordinator;
 import org.hibernate.jdbc.ReturningWork;
 import org.hibernate.jdbc.Work;
 import org.hibernate.loader.custom.CustomQuery;
 import org.hibernate.persister.entity.EntityPersister;
+import org.hibernate.procedure.ProcedureCall;
+import org.hibernate.query.NativeQuery;
+import org.hibernate.query.spi.NativeQueryImplementor;
+import org.hibernate.query.spi.QueryImplementor;
+import org.hibernate.query.spi.ScrollableResultsImplementor;
+import org.hibernate.resource.jdbc.spi.JdbcSessionContext;
+import org.hibernate.resource.transaction.spi.TransactionCoordinator;
 import org.hibernate.stat.SessionStatistics;
-import org.hibernate.type.Type;
+import org.hibernate.type.descriptor.sql.SqlTypeDescriptor;
 import org.junit.Before;
 import org.junit.Test;
 
+import javax.persistence.*;
+import javax.persistence.criteria.*;
+import javax.persistence.metamodel.Metamodel;
 import java.io.Serializable;
 import java.sql.Connection;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.junit.Assert.assertThat;
@@ -89,8 +70,14 @@ public void testFiltersSessionImplementorClassInstances() {
     assertThat(withFiltering < withoutFiltering, is(true));
   }
 
+  @SuppressWarnings("rawtypes")
   public static class SessionObject {
     Session session = new Session() {
+      @Override
+      public Session getSession() {
+        return null;
+      }
+
       @Override
       public SharedSessionBuilder sessionWithOptions() {
         throw new UnsupportedOperationException("Implement me!");
@@ -101,14 +88,35 @@ public void flush() throws HibernateException {
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public void setFlushMode(FlushModeType flushModeType) {
+      }
+
       @Override
       public void setFlushMode(final FlushMode flushMode) {
         throw new UnsupportedOperationException("Implement me!");
       }
 
       @Override
-      public FlushMode getFlushMode() {
-        throw new UnsupportedOperationException("Implement me!");
+      public FlushModeType getFlushMode() {
+        return null;
+      }
+
+      @Override
+      public void lock(Object o, LockModeType lockModeType) {
+      }
+
+      @Override
+      public void lock(Object o, LockModeType lockModeType, Map<String, Object> map) {
+      }
+
+      @Override
+      public void setHibernateFlushMode(FlushMode flushMode) {
+      }
+
+      @Override
+      public FlushMode getHibernateFlushMode() {
+        return null;
       }
 
       @Override
@@ -127,7 +135,7 @@ public SessionFactory getSessionFactory() {
       }
 
       @Override
-      public Connection close() throws HibernateException {
+      public void close() throws HibernateException {
         throw new UnsupportedOperationException("Implement me!");
       }
 
@@ -166,11 +174,31 @@ public Serializable getIdentifier(final Object o) {
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public boolean contains(String entityName, Object object) {
+        return false;
+      }
+
       @Override
       public boolean contains(final Object o) {
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public LockModeType getLockMode(Object o) {
+        return null;
+      }
+
+      @Override
+      public void setProperty(String s, Object o) {
+
+      }
+
+      @Override
+      public Map<String, Object> getProperties() {
+        return null;
+      }
+
       @Override
       public void evict(final Object o) {
         throw new UnsupportedOperationException("Implement me!");
@@ -266,6 +294,36 @@ public void persist(final Object o) {
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public void remove(Object o) {
+
+      }
+
+      @Override
+      public <T> T find(Class<T> aClass, Object o) {
+        return null;
+      }
+
+      @Override
+      public <T> T find(Class<T> aClass, Object o, Map<String, Object> map) {
+        return null;
+      }
+
+      @Override
+      public <T> T find(Class<T> aClass, Object o, LockModeType lockModeType) {
+        return null;
+      }
+
+      @Override
+      public <T> T find(Class<T> aClass, Object o, LockModeType lockModeType, Map<String, Object> map) {
+        return null;
+      }
+
+      @Override
+      public <T> T getReference(Class<T> aClass, Object o) {
+        return null;
+      }
+
       @Override
       public void persist(final String s, final Object o) {
         throw new UnsupportedOperationException("Implement me!");
@@ -301,6 +359,21 @@ public void refresh(final Object o) {
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public void refresh(Object o, Map<String, Object> map) {
+
+      }
+
+      @Override
+      public void refresh(Object o, LockModeType lockModeType) {
+
+      }
+
+      @Override
+      public void refresh(Object o, LockModeType lockModeType, Map<String, Object> map) {
+
+      }
+
       @Override
       public void refresh(final String s, final Object o) {
         throw new UnsupportedOperationException("Implement me!");
@@ -327,8 +400,8 @@ public LockMode getCurrentLockMode(final Object o) {
       }
 
       @Override
-      public Query createFilter(final Object o, final String s) {
-        throw new UnsupportedOperationException("Implement me!");
+      public org.hibernate.query.Query createFilter(Object collection, String queryString) {
+        return null;
       }
 
       @Override
@@ -336,6 +409,11 @@ public void clear() {
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public void detach(Object o) {
+
+      }
+
       @Override
       public Object get(final Class aClass, final Serializable serializable) {
         throw new UnsupportedOperationException("Implement me!");
@@ -376,6 +454,16 @@ public IdentifierLoadAccess byId(final String s) {
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public <T> MultiIdentifierLoadAccess<T> byMultipleIds(Class<T> entityClass) {
+        return null;
+      }
+
+      @Override
+      public MultiIdentifierLoadAccess byMultipleIds(String entityName) {
+        return null;
+      }
+
       @Override
       public IdentifierLoadAccess byId(final Class aClass) {
         throw new UnsupportedOperationException("Implement me!");
@@ -481,6 +569,16 @@ public void addEventListeners(final SessionEventListener... sessionEventListener
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public org.hibernate.query.Query getNamedQuery(String queryName) {
+        return null;
+      }
+
+      @Override
+      public org.hibernate.query.Query createQuery(String queryString) {
+        return null;
+      }
+
       @Override
       public String getTenantIdentifier() {
         throw new UnsupportedOperationException("Implement me!");
@@ -497,20 +595,155 @@ public Transaction getTransaction() {
       }
 
       @Override
-      public Query getNamedQuery(final String s) {
-        throw new UnsupportedOperationException("Implement me!");
+      public ProcedureCall getNamedProcedureCall(String name) {
+        return null;
       }
 
       @Override
-      public Query createQuery(final String s) {
-        throw new UnsupportedOperationException("Implement me!");
+      public ProcedureCall createStoredProcedureCall(String procedureName) {
+        return null;
+      }
+
+      @Override
+      public ProcedureCall createStoredProcedureCall(String procedureName, Class... resultClasses) {
+        return null;
+      }
+
+      @Override
+      public ProcedureCall createStoredProcedureCall(String procedureName, String... resultSetMappings) {
+        return null;
+      }
+
+      @Override
+      public EntityManagerFactory getEntityManagerFactory() {
+        return null;
+      }
+
+      @Override
+      public CriteriaBuilder getCriteriaBuilder() {
+        return null;
+      }
+
+      @Override
+      public Metamodel getMetamodel() {
+        return null;
+      }
+
+      @Override
+      public <T> EntityGraph<T> createEntityGraph(Class<T> aClass) {
+        return null;
+      }
+
+      @Override
+      public EntityGraph<?> createEntityGraph(String s) {
+        return null;
+      }
+
+      @Override
+      public EntityGraph<?> getEntityGraph(String s) {
+        return null;
+      }
+
+      @Override
+      public <T> List<EntityGraph<? super T>> getEntityGraphs(Class<T> aClass) {
+        return null;
+      }
+
+      @Override
+      public <T> org.hibernate.query.Query<T> createQuery(String queryString, Class<T> resultType) {
+        return null;
+      }
+
+      @Override
+      public org.hibernate.query.Query createNamedQuery(String name) {
+        return null;
+      }
+
+      @Override
+      public <T> org.hibernate.query.Query<T> createQuery(CriteriaQuery<T> criteriaQuery) {
+        return null;
+      }
+
+      @Override
+      public org.hibernate.query.Query createQuery(CriteriaUpdate updateQuery) {
+        return null;
+      }
+
+      @Override
+      public org.hibernate.query.Query createQuery(CriteriaDelete deleteQuery) {
+        return null;
+      }
+
+      @Override
+      public <T> org.hibernate.query.Query<T> createNamedQuery(String name, Class<T> resultType) {
+        return null;
+      }
+
+      @Override
+      public NativeQuery createNativeQuery(String s, Class aClass) {
+        return null;
+      }
+
+      @Override
+      public StoredProcedureQuery createNamedStoredProcedureQuery(String s) {
+        return null;
+      }
+
+      @Override
+      public StoredProcedureQuery createStoredProcedureQuery(String s) {
+        return null;
+      }
+
+      @Override
+      public StoredProcedureQuery createStoredProcedureQuery(String s, Class... classes) {
+        return null;
+      }
+
+      @Override
+      public StoredProcedureQuery createStoredProcedureQuery(String s, String... strings) {
+        return null;
+      }
+
+      @Override
+      public void joinTransaction() {
+
+      }
+
+      @Override
+      public boolean isJoinedToTransaction() {
+        return false;
+      }
+
+      @Override
+      public <T> T unwrap(Class<T> aClass) {
+        return null;
       }
 
       @Override
-      public SQLQuery createSQLQuery(final String s) {
+      public Object getDelegate() {
+        return null;
+      }
+
+      @Override
+      public NativeQuery createSQLQuery(final String s) {
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public NativeQuery createNativeQuery(String sqlString) {
+        return null;
+      }
+
+      @Override
+      public NativeQuery createNativeQuery(String sqlString, String resultSetMapping) {
+        return null;
+      }
+
+      @Override
+      public NativeQuery getNamedNativeQuery(String name) {
+        return null;
+      }
+
       @Override
       public Criteria createCriteria(final Class aClass) {
         throw new UnsupportedOperationException("Implement me!");
@@ -530,28 +763,74 @@ public Criteria createCriteria(final String s) {
       public Criteria createCriteria(final String s, final String s2) {
         throw new UnsupportedOperationException("Implement me!");
       }
+
+      @Override
+      public Integer getJdbcBatchSize() {
+        return null;
+      }
+
+      @Override
+      public void setJdbcBatchSize(Integer jdbcBatchSize) {
+
+      }
     };
     int value;
   }
+  @SuppressWarnings({"unused", "rawtypes"})
   public static class SessionImplementorObject {
     SessionImplementor sessionImplementor = new SessionImplementor() {
+      @Override
+      public boolean useStreamForLobBinding() {
+        return false;
+      }
+
+      @Override
+      public LobCreator getLobCreator() {
+        return null;
+      }
+
+      @Override
+      public SqlTypeDescriptor remapSqlTypeDescriptor(SqlTypeDescriptor sqlTypeDescriptor) {
+        return null;
+      }
+
+      @Override
+      public TimeZone getJdbcTimeZone() {
+        return null;
+      }
+
+      @Override
+      public boolean shouldAutoJoinTransaction() {
+        return false;
+      }
+
       @Override
       public String getTenantIdentifier() {
         throw new UnsupportedOperationException("Implement me!");
       }
 
       @Override
-      public JdbcConnectionAccess getJdbcConnectionAccess() {
-        throw new UnsupportedOperationException("Implement me!");
+      public void close() {
+
       }
 
       @Override
-      public EntityKey generateEntityKey(final Serializable serializable, final EntityPersister entityPersister) {
+      public UUID getSessionIdentifier() {
+        return null;
+      }
+
+      @Override
+      public JdbcSessionContext getJdbcSessionContext() {
+        return null;
+      }
+
+      @Override
+      public JdbcConnectionAccess getJdbcConnectionAccess() {
         throw new UnsupportedOperationException("Implement me!");
       }
 
       @Override
-      public CacheKey generateCacheKey(final Serializable serializable, final Type type, final String s) {
+      public EntityKey generateEntityKey(final Serializable serializable, final EntityPersister entityPersister) {
         throw new UnsupportedOperationException("Implement me!");
       }
 
@@ -566,8 +845,8 @@ public void setAutoClear(final boolean b) {
       }
 
       @Override
-      public void disableTransactionAutoJoin() {
-        throw new UnsupportedOperationException("Implement me!");
+      public SessionImplementor getSession() {
+        return null;
       }
 
       @Override
@@ -575,6 +854,16 @@ public boolean isTransactionInProgress() {
         throw new UnsupportedOperationException("Implement me!");
       }
 
+      @Override
+      public Transaction accessTransaction() {
+        return null;
+      }
+
+      @Override
+      public LockOptions getLockRequest(LockModeType lockModeType, Map<String, Object> properties) {
+        return null;
+      }
+
       @Override
       public void initializeCollection(final PersistentCollection persistentCollection, final boolean b) throws HibernateException {
         throw new UnsupportedOperationException("Implement me!");
@@ -611,13 +900,13 @@ public Iterator iterate(final String s, final QueryParameters queryParameters) t
       }
 
       @Override
-      public ScrollableResults scroll(final String s, final QueryParameters queryParameters) throws HibernateException {
-        throw new UnsupportedOperationException("Implement me!");
+      public ScrollableResultsImplementor scroll(String query, QueryParameters queryParameters) throws HibernateException {
+        return null;
       }
 
       @Override
-      public ScrollableResults scroll(final Criteria criteria, final ScrollMode scrollMode) {
-        throw new UnsupportedOperationException("Implement me!");
+      public ScrollableResultsImplementor scroll(Criteria criteria, ScrollMode scrollMode) {
+        return null;
       }
 
       @Override
@@ -671,8 +960,8 @@ public List listCustomQuery(final CustomQuery customQuery, final QueryParameters
       }
 
       @Override
-      public ScrollableResults scrollCustomQuery(final CustomQuery customQuery, final QueryParameters queryParameters) throws HibernateException {
-        throw new UnsupportedOperationException("Implement me!");
+      public ScrollableResultsImplementor scrollCustomQuery(CustomQuery customQuery, QueryParameters queryParameters) throws HibernateException {
+        return null;
       }
 
       @Override
@@ -681,33 +970,28 @@ public List list(final NativeSQLQuerySpecification nativeSQLQuerySpecification,
       }
 
       @Override
-      public ScrollableResults scroll(final NativeSQLQuerySpecification nativeSQLQuerySpecification, final QueryParameters queryParameters) throws HibernateException {
-        throw new UnsupportedOperationException("Implement me!");
-      }
-
-      @Override
-      public Object getFilterParameterValue(final String s) {
-        throw new UnsupportedOperationException("Implement me!");
+      public ScrollableResultsImplementor scroll(NativeSQLQuerySpecification spec, QueryParameters queryParameters) {
+        return null;
       }
 
       @Override
-      public Type getFilterParameterType(final String s) {
+      public int getDontFlushFromFind() {
         throw new UnsupportedOperationException("Implement me!");
       }
 
       @Override
-      public Map getEnabledFilters() {
+      public PersistenceContext getPersistenceContext() {
         throw new UnsupportedOperationException("Implement me!");
       }
 
       @Override
-      public int getDontFlushFromFind() {
-        throw new UnsupportedOperationException("Implement me!");
+      public JdbcCoordinator getJdbcCoordinator() {
+        return null;
       }
 
       @Override
-      public PersistenceContext getPersistenceContext() {
-        throw new UnsupportedOperationException("Implement me!");
+      public JdbcServices getJdbcServices() {
+        return null;
       }
 
       @Override
@@ -736,73 +1020,804 @@ public boolean isOpen() {
       }
 
       @Override
-      public boolean isConnected() {
-        throw new UnsupportedOperationException("Implement me!");
+      public EntityManagerFactory getEntityManagerFactory() {
+        return null;
       }
 
       @Override
-      public FlushMode getFlushMode() {
-        throw new UnsupportedOperationException("Implement me!");
+      public CriteriaBuilder getCriteriaBuilder() {
+        return null;
       }
 
       @Override
-      public void setFlushMode(final FlushMode flushMode) {
-        throw new UnsupportedOperationException("Implement me!");
+      public Metamodel getMetamodel() {
+        return null;
       }
 
       @Override
-      public Connection connection() {
-        throw new UnsupportedOperationException("Implement me!");
+      public <T> EntityGraph<T> createEntityGraph(Class<T> aClass) {
+        return null;
       }
 
       @Override
-      public void flush() {
-        throw new UnsupportedOperationException("Implement me!");
+      public EntityGraph<?> createEntityGraph(String s) {
+        return null;
       }
 
       @Override
-      public Query getNamedQuery(final String s) {
-        throw new UnsupportedOperationException("Implement me!");
+      public EntityGraph<?> getEntityGraph(String s) {
+        return null;
       }
 
       @Override
-      public Query getNamedSQLQuery(final String s) {
-        throw new UnsupportedOperationException("Implement me!");
+      public <T> List<EntityGraph<? super T>> getEntityGraphs(Class<T> aClass) {
+        return null;
       }
 
       @Override
-      public boolean isEventSource() {
+      public boolean isConnected() {
         throw new UnsupportedOperationException("Implement me!");
       }
 
       @Override
-      public void afterScrollOperation() {
-        throw new UnsupportedOperationException("Implement me!");
+      public Transaction beginTransaction() {
+        return null;
       }
 
       @Override
-      public String getFetchProfile() {
-        throw new UnsupportedOperationException("Implement me!");
+      public Transaction getTransaction() {
+        return null;
       }
 
       @Override
-      public void setFetchProfile(final String s) {
-        throw new UnsupportedOperationException("Implement me!");
+      public ProcedureCall getNamedProcedureCall(String name) {
+        return null;
       }
 
       @Override
-      public TransactionCoordinator getTransactionCoordinator() {
-        throw new UnsupportedOperationException("Implement me!");
+      public ProcedureCall createStoredProcedureCall(String procedureName) {
+        return null;
       }
 
       @Override
-      public boolean isClosed() {
-        throw new UnsupportedOperationException("Implement me!");
+      public ProcedureCall createStoredProcedureCall(String procedureName, Class... resultClasses) {
+        return null;
       }
 
       @Override
-      public LoadQueryInfluencers getLoadQueryInfluencers() {
-        throw new UnsupportedOperationException("Implement me!");
+      public ProcedureCall createStoredProcedureCall(String procedureName, String... resultSetMappings) {
+        return null;
+      }
+
+      @Override
+      public Criteria createCriteria(Class persistentClass) {
+        return null;
+      }
+
+      @Override
+      public Criteria createCriteria(Class persistentClass, String alias) {
+        return null;
+      }
+
+      @Override
+      public Criteria createCriteria(String entityName) {
+        return null;
+      }
+
+      @Override
+      public Criteria createCriteria(String entityName, String alias) {
+        return null;
+      }
+
+      @Override
+      public Integer getJdbcBatchSize() {
+        return null;
+      }
+
+      @Override
+      public void setJdbcBatchSize(Integer jdbcBatchSize) {
+      }
+
+      @Override
+      public void lock(Object o, LockModeType lockModeType) {
+      }
+
+      @Override
+      public void lock(Object o, LockModeType lockModeType, Map<String, Object> map) {
+      }
+
+      @Override
+      public void setHibernateFlushMode(FlushMode flushMode) {
+      }
+
+      @Override
+      public FlushMode getHibernateFlushMode() {
+        return null;
+      }
+
+      @Override
+      public void setFlushMode(final FlushMode flushMode) {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public FlushModeType getFlushMode() {
+        return null;
+      }
+
+      @Override
+      public Connection connection() {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public SharedSessionBuilder sessionWithOptions() {
+        return null;
+      }
+
+      @Override
+      public void flush() {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public void setFlushMode(FlushModeType flushModeType) {
+
+      }
+
+      @Override
+      public SessionFactoryImplementor getSessionFactory() {
+        return null;
+      }
+
+      @Override
+      public void cancelQuery() throws HibernateException {
+
+      }
+
+      @Override
+      public boolean isDirty() throws HibernateException {
+        return false;
+      }
+
+      @Override
+      public boolean isDefaultReadOnly() {
+        return false;
+      }
+
+      @Override
+      public void setDefaultReadOnly(boolean readOnly) {
+
+      }
+
+      @Override
+      public Serializable getIdentifier(Object object) {
+        return null;
+      }
+
+      @Override
+      public boolean contains(String entityName, Object object) {
+        return false;
+      }
+
+      @Override
+      public void evict(Object object) {
+
+      }
+
+      @Override
+      public <T> T load(Class<T> theClass, Serializable id, LockMode lockMode) {
+        return null;
+      }
+
+      @Override
+      public <T> T load(Class<T> theClass, Serializable id, LockOptions lockOptions) {
+        return null;
+      }
+
+      @Override
+      public Object load(String entityName, Serializable id, LockMode lockMode) {
+        return null;
+      }
+
+      @Override
+      public Object load(String entityName, Serializable id, LockOptions lockOptions) {
+        return null;
+      }
+
+      @Override
+      public <T> T load(Class<T> theClass, Serializable id) {
+        return null;
+      }
+
+      @Override
+      public Object load(String entityName, Serializable id) {
+        return null;
+      }
+
+      @Override
+      public void load(Object object, Serializable id) {
+
+      }
+
+      @Override
+      public void replicate(Object object, ReplicationMode replicationMode) {
+
+      }
+
+      @Override
+      public void replicate(String entityName, Object object, ReplicationMode replicationMode) {
+
+      }
+
+      @Override
+      public Serializable save(Object object) {
+        return null;
+      }
+
+      @Override
+      public Serializable save(String entityName, Object object) {
+        return null;
+      }
+
+      @Override
+      public void saveOrUpdate(Object object) {
+
+      }
+
+      @Override
+      public void saveOrUpdate(String entityName, Object object) {
+
+      }
+
+      @Override
+      public void update(Object object) {
+
+      }
+
+      @Override
+      public void update(String entityName, Object object) {
+
+      }
+
+      @Override
+      public Object merge(Object object) {
+        return null;
+      }
+
+      @Override
+      public Object merge(String entityName, Object object) {
+        return null;
+      }
+
+      @Override
+      public void persist(Object object) {
+
+      }
+
+      @Override
+      public void remove(Object o) {
+
+      }
+
+      @Override
+      public <T> T find(Class<T> aClass, Object o) {
+        return null;
+      }
+
+      @Override
+      public <T> T find(Class<T> aClass, Object o, Map<String, Object> map) {
+        return null;
+      }
+
+      @Override
+      public <T> T find(Class<T> aClass, Object o, LockModeType lockModeType) {
+        return null;
+      }
+
+      @Override
+      public <T> T find(Class<T> aClass, Object o, LockModeType lockModeType, Map<String, Object> map) {
+        return null;
+      }
+
+      @Override
+      public <T> T getReference(Class<T> aClass, Object o) {
+        return null;
+      }
+
+      @Override
+      public void persist(String entityName, Object object) {
+
+      }
+
+      @Override
+      public void delete(Object object) {
+
+      }
+
+      @Override
+      public void delete(String entityName, Object object) {
+
+      }
+
+      @Override
+      public void lock(Object object, LockMode lockMode) {
+
+      }
+
+      @Override
+      public void lock(String entityName, Object object, LockMode lockMode) {
+
+      }
+
+      @Override
+      public LockRequest buildLockRequest(LockOptions lockOptions) {
+        return null;
+      }
+
+      @Override
+      public void refresh(Object object) {
+
+      }
+
+      @Override
+      public void refresh(Object o, Map<String, Object> map) {
+
+      }
+
+      @Override
+      public void refresh(Object o, LockModeType lockModeType) {
+
+      }
+
+      @Override
+      public void refresh(Object o, LockModeType lockModeType, Map<String, Object> map) {
+
+      }
+
+      @Override
+      public void refresh(String entityName, Object object) {
+
+      }
+
+      @Override
+      public void refresh(Object object, LockMode lockMode) {
+
+      }
+
+      @Override
+      public void refresh(Object object, LockOptions lockOptions) {
+
+      }
+
+      @Override
+      public void refresh(String entityName, Object object, LockOptions lockOptions) {
+
+      }
+
+      @Override
+      public LockMode getCurrentLockMode(Object object) {
+        return null;
+      }
+
+      @Override
+      public org.hibernate.query.Query createFilter(Object collection, String queryString) {
+        return null;
+      }
+
+      @Override
+      public void clear() {
+
+      }
+
+      @Override
+      public void detach(Object o) {
+
+      }
+
+      @Override
+      public boolean contains(Object o) {
+        return false;
+      }
+
+      @Override
+      public LockModeType getLockMode(Object o) {
+        return null;
+      }
+
+      @Override
+      public void setProperty(String s, Object o) {
+
+      }
+
+      @Override
+      public Map<String, Object> getProperties() {
+        return null;
+      }
+
+      @Override
+      public <T> T get(Class<T> entityType, Serializable id) {
+        return null;
+      }
+
+      @Override
+      public <T> T get(Class<T> entityType, Serializable id, LockMode lockMode) {
+        return null;
+      }
+
+      @Override
+      public <T> T get(Class<T> entityType, Serializable id, LockOptions lockOptions) {
+        return null;
+      }
+
+      @Override
+      public Object get(String entityName, Serializable id) {
+        return null;
+      }
+
+      @Override
+      public Object get(String entityName, Serializable id, LockMode lockMode) {
+        return null;
+      }
+
+      @Override
+      public Object get(String entityName, Serializable id, LockOptions lockOptions) {
+        return null;
+      }
+
+      @Override
+      public String getEntityName(Object object) {
+        return null;
+      }
+
+      @Override
+      public IdentifierLoadAccess byId(String entityName) {
+        return null;
+      }
+
+      @Override
+      public <T> MultiIdentifierLoadAccess<T> byMultipleIds(Class<T> entityClass) {
+        return null;
+      }
+
+      @Override
+      public MultiIdentifierLoadAccess byMultipleIds(String entityName) {
+        return null;
+      }
+
+      @Override
+      public <T> IdentifierLoadAccess<T> byId(Class<T> entityClass) {
+        return null;
+      }
+
+      @Override
+      public NaturalIdLoadAccess byNaturalId(String entityName) {
+        return null;
+      }
+
+      @Override
+      public <T> NaturalIdLoadAccess<T> byNaturalId(Class<T> entityClass) {
+        return null;
+      }
+
+      @Override
+      public SimpleNaturalIdLoadAccess bySimpleNaturalId(String entityName) {
+        return null;
+      }
+
+      @Override
+      public <T> SimpleNaturalIdLoadAccess<T> bySimpleNaturalId(Class<T> entityClass) {
+        return null;
+      }
+
+      @Override
+      public Filter enableFilter(String filterName) {
+        return null;
+      }
+
+      @Override
+      public Filter getEnabledFilter(String filterName) {
+        return null;
+      }
+
+      @Override
+      public void disableFilter(String filterName) {
+
+      }
+
+      @Override
+      public SessionStatistics getStatistics() {
+        return null;
+      }
+
+      @Override
+      public boolean isReadOnly(Object entityOrProxy) {
+        return false;
+      }
+
+      @Override
+      public void setReadOnly(Object entityOrProxy, boolean readOnly) {
+
+      }
+
+      @Override
+      public void doWork(Work work) throws HibernateException {
+
+      }
+
+      @Override
+      public <T> T doReturningWork(ReturningWork<T> work) throws HibernateException {
+        return null;
+      }
+
+      @Override
+      public Connection disconnect() {
+        return null;
+      }
+
+      @Override
+      public void reconnect(Connection connection) {
+
+      }
+
+      @Override
+      public boolean isFetchProfileEnabled(String name) throws UnknownProfileException {
+        return false;
+      }
+
+      @Override
+      public void enableFetchProfile(String name) throws UnknownProfileException {
+
+      }
+
+      @Override
+      public void disableFetchProfile(String name) throws UnknownProfileException {
+
+      }
+
+      @Override
+      public TypeHelper getTypeHelper() {
+        return null;
+      }
+
+      @Override
+      public LobHelper getLobHelper() {
+        return null;
+      }
+
+      @Override
+      public void addEventListeners(SessionEventListener... listeners) {
+
+      }
+
+      @Override
+      public boolean isFlushBeforeCompletionEnabled() {
+        return false;
+      }
+
+      @Override
+      public ActionQueue getActionQueue() {
+        return null;
+      }
+
+      @Override
+      public Object instantiate(EntityPersister persister, Serializable id) throws HibernateException {
+        return null;
+      }
+
+      @Override
+      public void forceFlush(EntityEntry e) throws HibernateException {
+
+      }
+
+      @Override
+      public QueryImplementor createQuery(String queryString) {
+        return null;
+      }
+
+      @Override
+      public <T> QueryImplementor<T> createQuery(String queryString, Class<T> resultType) {
+        return null;
+      }
+
+      @Override
+      public <T> QueryImplementor<T> createNamedQuery(String name, Class<T> resultType) {
+        return null;
+      }
+
+      @Override
+      public QueryImplementor createNamedQuery(String name) {
+        return null;
+      }
+
+      @Override
+      public NativeQueryImplementor createNativeQuery(String sqlString) {
+        return null;
+      }
+
+      @Override
+      public NativeQueryImplementor createNativeQuery(String sqlString, Class resultClass) {
+        return null;
+      }
+
+      @Override
+      public NativeQueryImplementor createNativeQuery(String sqlString, String resultSetMapping) {
+        return null;
+      }
+
+      @Override
+      public StoredProcedureQuery createNamedStoredProcedureQuery(String s) {
+        return null;
+      }
+
+      @Override
+      public StoredProcedureQuery createStoredProcedureQuery(String s) {
+        return null;
+      }
+
+      @Override
+      public StoredProcedureQuery createStoredProcedureQuery(String s, Class... classes) {
+        return null;
+      }
+
+      @Override
+      public StoredProcedureQuery createStoredProcedureQuery(String s, String... strings) {
+        return null;
+      }
+
+      @Override
+      public void joinTransaction() {
+
+      }
+
+      @Override
+      public boolean isJoinedToTransaction() {
+        return false;
+      }
+
+      @Override
+      public <T> T unwrap(Class<T> aClass) {
+        return null;
+      }
+
+      @Override
+      public Object getDelegate() {
+        return null;
+      }
+
+      @Override
+      public NativeQueryImplementor getNamedNativeQuery(String name) {
+        return null;
+      }
+
+      @Override
+      public QueryImplementor getNamedQuery(final String s) {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public NativeQueryImplementor getNamedSQLQuery(final String s) {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public <T> QueryImplementor<T> createQuery(CriteriaQuery<T> criteriaQuery) {
+        return null;
+      }
+
+      @Override
+      public QueryImplementor createQuery(CriteriaUpdate updateQuery) {
+        return null;
+      }
+
+      @Override
+      public QueryImplementor createQuery(CriteriaDelete deleteQuery) {
+        return null;
+      }
+
+      @Override
+      public <T> QueryImplementor<T> createQuery(String jpaqlString, Class<T> resultClass, Selection selection, QueryOptions queryOptions) {
+        return null;
+      }
+
+      @Override
+      public void merge(String entityName, Object object, Map copiedAlready) throws HibernateException {
+
+      }
+
+      @Override
+      public void persist(String entityName, Object object, Map createdAlready) throws HibernateException {
+
+      }
+
+      @Override
+      public void persistOnFlush(String entityName, Object object, Map copiedAlready) {
+
+      }
+
+      @Override
+      public void refresh(String entityName, Object object, Map refreshedAlready) throws HibernateException {
+
+      }
+
+      @Override
+      public void delete(String entityName, Object child, boolean isCascadeDeleteEnabled, Set transientEntities) {
+
+      }
+
+      @Override
+      public void removeOrphanBeforeUpdates(String entityName, Object child) {
+
+      }
+
+      @Override
+      public boolean isEventSource() {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public void afterScrollOperation() {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public boolean shouldAutoClose() {
+        return false;
+      }
+
+      @Override
+      public boolean isAutoCloseSessionEnabled() {
+        return false;
+      }
+
+      @Override
+      public TransactionCoordinator getTransactionCoordinator() {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public void afterTransactionBegin() {
+
+      }
+
+      @Override
+      public void beforeTransactionCompletion() {
+
+      }
+
+      @Override
+      public void afterTransactionCompletion(boolean successful, boolean delayed) {
+
+      }
+
+      @Override
+      public void flushBeforeTransactionCompletion() {
+
+      }
+
+      @Override
+      public boolean isClosed() {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public void checkOpen(boolean markForRollbackIfClosed) {
+
+      }
+
+      @Override
+      public void markForRollbackOnly() {
+
+      }
+
+      @Override
+      public LoadQueryInfluencers getLoadQueryInfluencers() {
+        throw new UnsupportedOperationException("Implement me!");
+      }
+
+      @Override
+      public ExceptionConverter getExceptionConverter() {
+        return null;
       }
 
       @Override