diff --git a/src/Umbraco.Core/Models/DataTypeDefinition.cs b/src/Umbraco.Core/Models/DataTypeDefinition.cs
index a4dff4432b..4f8069ae16 100644
--- a/src/Umbraco.Core/Models/DataTypeDefinition.cs
+++ b/src/Umbraco.Core/Models/DataTypeDefinition.cs
@@ -14,7 +14,7 @@ namespace Umbraco.Core.Models
     /// </remarks>
     [Serializable]
     [DataContract(IsReference = true)]
-    public class DataTypeDefinition : Entity, IAggregateRoot
+    public class DataTypeDefinition : Entity, IDataTypeDefinition
     {
         private int _parentId;
         private string _name;
diff --git a/src/Umbraco.Core/Models/IDataTypeDefinition.cs b/src/Umbraco.Core/Models/IDataTypeDefinition.cs
new file mode 100644
index 0000000000..ce87fcb5e7
--- /dev/null
+++ b/src/Umbraco.Core/Models/IDataTypeDefinition.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Runtime.Serialization;
+using Umbraco.Core.Models.EntityBase;
+
+namespace Umbraco.Core.Models
+{
+    public interface IDataTypeDefinition : IAggregateRoot
+    {
+        /// <summary>
+        /// Gets or sets the Id of the Parent entity
+        /// </summary>
+        /// <remarks>Might not be necessary if handled as a relation?</remarks>
+        [DataMember]
+        int ParentId { get; set; }
+
+        /// <summary>
+        /// Gets or sets the name of the current entity
+        /// </summary>
+        [DataMember]
+        string Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the sort order of the content entity
+        /// </summary>
+        [DataMember]
+        int SortOrder { get; set; }
+
+        /// <summary>
+        /// Gets or sets the level of the content entity
+        /// </summary>
+        [DataMember]
+        int Level { get; set; }
+
+        /// <summary>
+        /// Gets or sets the path
+        /// </summary>
+        [DataMember]
+        string Path //Setting this value should be handled by the class not the user
+        { get; set; }
+
+        /// <summary>
+        /// Id of the user who created this entity
+        /// </summary>
+        [DataMember]
+        int UserId { get; set; }
+
+        /// <summary>
+        /// Boolean indicating whether this entity is Trashed or not.
+        /// </summary>
+        [DataMember]
+        bool Trashed { get; }
+
+        /// <summary>
+        /// Id of the DataType control
+        /// </summary>
+        [DataMember]
+        Guid ControlId { get; }
+
+        /// <summary>
+        /// Gets or Sets the DatabaseType for which the DataType's value is saved as
+        /// </summary>
+        [DataMember]
+        DataTypeDatabaseType DatabaseType { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Core/Models/PropertyType.cs b/src/Umbraco.Core/Models/PropertyType.cs
index 08a70a4d54..853044de9b 100644
--- a/src/Umbraco.Core/Models/PropertyType.cs
+++ b/src/Umbraco.Core/Models/PropertyType.cs
@@ -104,9 +104,9 @@ namespace Umbraco.Core.Models
         }
 
         /// <summary>
-        /// Gets of Sets the Id of the DataType, which the PropertyType is "wrapping"
+        /// Gets of Sets the Id of the DataType (Definition), which the PropertyType is "wrapping"
         /// </summary>
-        /// <remarks>This is actually the Id of the DataTypeDefinition</remarks>
+        /// <remarks>This is actually the Id of the <see cref="IDataTypeDefinition"/></remarks>
         [DataMember]
         public int DataTypeId
         {
diff --git a/src/Umbraco.Core/Persistence/Factories/DataTypeDefinitionFactory.cs b/src/Umbraco.Core/Persistence/Factories/DataTypeDefinitionFactory.cs
index 058a867be3..d9d4636e4d 100644
--- a/src/Umbraco.Core/Persistence/Factories/DataTypeDefinitionFactory.cs
+++ b/src/Umbraco.Core/Persistence/Factories/DataTypeDefinitionFactory.cs
@@ -5,7 +5,7 @@ using Umbraco.Core.Models.Rdbms;
 
 namespace Umbraco.Core.Persistence.Factories
 {
-    internal class DataTypeDefinitionFactory : IEntityFactory<DataTypeDefinition, DataTypeDto>
+    internal class DataTypeDefinitionFactory : IEntityFactory<IDataTypeDefinition, DataTypeDto>
     {
         private readonly Guid _nodeObjectTypeId;
         private int _primaryKey;
@@ -17,7 +17,7 @@ namespace Umbraco.Core.Persistence.Factories
 
         #region Implementation of IEntityFactory<DataTypeDefinition,DataTypeDto>
 
-        public DataTypeDefinition BuildEntity(DataTypeDto dto)
+        public IDataTypeDefinition BuildEntity(DataTypeDto dto)
         {
             var dataTypeDefinition = new DataTypeDefinition(dto.ControlId)
                                          {
@@ -41,7 +41,7 @@ namespace Umbraco.Core.Persistence.Factories
             return dataTypeDefinition;
         }
 
-        public DataTypeDto BuildDto(DataTypeDefinition entity)
+        public DataTypeDto BuildDto(IDataTypeDefinition entity)
         {
             var dataTypeDto = new DataTypeDto
                                   {
@@ -66,7 +66,7 @@ namespace Umbraco.Core.Persistence.Factories
             _primaryKey = primaryKey;
         }
 
-        private NodeDto BuildNodeDto(DataTypeDefinition entity)
+        private NodeDto BuildNodeDto(IDataTypeDefinition entity)
         {
             var nodeDto = new NodeDto
                               {
diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs
new file mode 100644
index 0000000000..5ddcbbbdc4
--- /dev/null
+++ b/src/Umbraco.Core/Persistence/Mappers/PropertyGroupMapper.cs
@@ -0,0 +1,49 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Mappers
+{
+    /// <summary>
+    /// Represents a <see cref="PropertyGroup"/> to DTO mapper used to translate the properties of the public api 
+    /// implementation to that of the database's DTO as sql: [tableName].[columnName].
+    /// </summary>
+    internal sealed class PropertyGroupMapper : BaseMapper
+    {
+        private static readonly ConcurrentDictionary<string, DtoMapModel> PropertyInfoCache = new ConcurrentDictionary<string, DtoMapModel>();
+
+        internal static PropertyGroupMapper Instance = new PropertyGroupMapper();
+
+        private PropertyGroupMapper()
+        {
+            BuildMap();
+        }
+
+        #region Overrides of BaseMapper
+
+        internal override void BuildMap()
+        {
+            CacheMap<PropertyGroup, PropertyTypeGroupDto>(src => src.Id, dto => dto.Id);
+            CacheMap<PropertyGroup, PropertyTypeGroupDto>(src => src.ParentId, dto => dto.ParentGroupId);
+            CacheMap<PropertyGroup, PropertyTypeGroupDto>(src => src.SortOrder, dto => dto.SortOrder);
+            CacheMap<PropertyGroup, PropertyTypeGroupDto>(src => src.Name, dto => dto.Text);
+        }
+
+        internal override string Map(string propertyName)
+        {
+            var dtoTypeProperty = PropertyInfoCache[propertyName];
+
+            return base.GetColumnName(dtoTypeProperty.Type, dtoTypeProperty.PropertyInfo);
+        }
+
+        internal override void CacheMap<TSource, TDestination>(Expression<Func<TSource, object>> sourceMember, Expression<Func<TDestination, object>> destinationMember)
+        {
+            var property = base.ResolveMapping(sourceMember, destinationMember);
+            PropertyInfoCache.AddOrUpdate(property.SourcePropertyName, property, (x, y) => property);
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs b/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs
new file mode 100644
index 0000000000..ca572f11ab
--- /dev/null
+++ b/src/Umbraco.Core/Persistence/Mappers/PropertyTypeMapper.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Rdbms;
+
+namespace Umbraco.Core.Persistence.Mappers
+{
+    /// <summary>
+    /// Represents a <see cref="PropertyType"/> to DTO mapper used to translate the properties of the public api 
+    /// implementation to that of the database's DTO as sql: [tableName].[columnName].
+    /// </summary>
+    internal sealed class PropertyTypeMapper : BaseMapper
+    {
+        private static readonly ConcurrentDictionary<string, DtoMapModel> PropertyInfoCache = new ConcurrentDictionary<string, DtoMapModel>();
+
+        internal static PropertyTypeMapper Instance = new PropertyTypeMapper();
+
+        private PropertyTypeMapper()
+        {
+            BuildMap();
+        }
+
+        #region Overrides of BaseMapper
+
+        internal override void BuildMap()
+        {
+            if(PropertyInfoCache.IsEmpty)
+            {
+                CacheMap<PropertyType, PropertyTypeDto>(src => src.Id, dto => dto.Id);
+                CacheMap<PropertyType, PropertyTypeDto>(src => src.Alias, dto => dto.Alias);
+                CacheMap<PropertyType, PropertyTypeDto>(src => src.DataTypeId, dto => dto.DataTypeId);
+                CacheMap<PropertyType, PropertyTypeDto>(src => src.Description, dto => dto.Description);
+                CacheMap<PropertyType, PropertyTypeDto>(src => src.HelpText, dto => dto.HelpText);
+                CacheMap<PropertyType, PropertyTypeDto>(src => src.Mandatory, dto => dto.Mandatory);
+                CacheMap<PropertyType, PropertyTypeDto>(src => src.Name, dto => dto.Name);
+                CacheMap<PropertyType, PropertyTypeDto>(src => src.SortOrder, dto => dto.SortOrder);
+                CacheMap<PropertyType, PropertyTypeDto>(src => src.ValidationRegExp, dto => dto.ValidationRegExp);
+                CacheMap<PropertyType, DataTypeDto>(src => src.DataTypeControlId, dto => dto.ControlId);
+                CacheMap<PropertyType, DataTypeDto>(src => src.DataTypeDatabaseType, dto => dto.DbType);
+            }
+        }
+
+        internal override string Map(string propertyName)
+        {
+            var dtoTypeProperty = PropertyInfoCache[propertyName];
+
+            return base.GetColumnName(dtoTypeProperty.Type, dtoTypeProperty.PropertyInfo);
+        }
+
+        internal override void CacheMap<TSource, TDestination>(Expression<Func<TSource, object>> sourceMember, Expression<Func<TDestination, object>> destinationMember)
+        {
+            var property = base.ResolveMapping(sourceMember, destinationMember);
+            PropertyInfoCache.AddOrUpdate(property.SourcePropertyName, property, (x, y) => property);
+        }
+
+        #endregion
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs
index 2ba1de3642..ac99d6b9a8 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs
@@ -7,6 +7,7 @@ using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Rdbms;
 using Umbraco.Core.Persistence.Caching;
 using Umbraco.Core.Persistence.Factories;
+using Umbraco.Core.Persistence.Querying;
 using Umbraco.Core.Persistence.Relators;
 using Umbraco.Core.Persistence.UnitOfWork;
 
@@ -29,6 +30,25 @@ namespace Umbraco.Core.Persistence.Repositories
         {
         }
 
+        protected IEnumerable<int> PerformGetByQuery(IQuery<PropertyType> query)
+        {
+            var sqlClause = new Sql();
+            sqlClause.Select("*");
+            sqlClause.From("cmsPropertyTypeGroup");
+            sqlClause.RightJoin("cmsPropertyType ON [cmsPropertyTypeGroup].[id] = [cmsPropertyType].[propertyTypeGroupId]");
+            sqlClause.InnerJoin("cmsDataType ON [cmsPropertyType].[dataTypeId] = [cmsDataType].[nodeId]");
+
+            var translator = new SqlTranslator<PropertyType>(sqlClause, query);
+            var sql = translator.Translate();
+
+            var dtos = Database.Fetch<PropertyTypeGroupDto, PropertyTypeDto, DataTypeDto, PropertyTypeGroupDto>(new GroupPropertyTypeRelator().Map, sql);
+
+            foreach (var dto in dtos.DistinctBy(x => x.ContentTypeNodeId))
+            {
+                yield return dto.ContentTypeNodeId;
+            }
+        }
+
         protected void PersistNewBaseContentType(ContentTypeDto dto, IContentTypeComposition entity)
         {
             //Logic for setting Path, Level and SortOrder
diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
index e7afb1cd3a..6f1d228eef 100644
--- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs
@@ -88,6 +88,15 @@ namespace Umbraco.Core.Persistence.Repositories
 
         #endregion
 
+        public IEnumerable<IContentType> GetByQuery(IQuery<PropertyType> query)
+        {
+            var ints = PerformGetByQuery(query);
+            foreach (var i in ints)
+            {
+                yield return Get(i);
+            }
+        }
+
         #region Overrides of PetaPocoRepositoryBase<int,IContentType>
 
         protected override Sql GetBaseQuery(bool isCount)
diff --git a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
index baafb40e71..6694178e49 100644
--- a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs
@@ -14,7 +14,7 @@ namespace Umbraco.Core.Persistence.Repositories
     /// <summary>
     /// Represents a repository for doing CRUD operations for <see cref="DataTypeDefinition"/>
     /// </summary>
-    internal class DataTypeDefinitionRepository : PetaPocoRepositoryBase<int, DataTypeDefinition>, IDataTypeDefinitionRepository
+    internal class DataTypeDefinitionRepository : PetaPocoRepositoryBase<int, IDataTypeDefinition>, IDataTypeDefinitionRepository
     {
         public DataTypeDefinitionRepository(IUnitOfWork work) : base(work)
         {
@@ -27,7 +27,7 @@ namespace Umbraco.Core.Persistence.Repositories
 
         #region Overrides of RepositoryBase<int,DataTypeDefinition>
 
-        protected override DataTypeDefinition PerformGet(int id)
+        protected override IDataTypeDefinition PerformGet(int id)
         {
             var dataTypeSql = GetBaseQuery(false);
             dataTypeSql.Append(GetBaseWhereClause(id));
@@ -39,11 +39,11 @@ namespace Umbraco.Core.Persistence.Repositories
 
             var factory = new DataTypeDefinitionFactory(NodeObjectTypeId);
             var definition = factory.BuildEntity(dataTypeDto);
-            definition.ResetDirtyProperties();
+            ((DataTypeDefinition)definition).ResetDirtyProperties();
             return definition;
         }
 
-        protected override IEnumerable<DataTypeDefinition> PerformGetAll(params int[] ids)
+        protected override IEnumerable<IDataTypeDefinition> PerformGetAll(params int[] ids)
         {
             if (ids.Any())
             {
@@ -62,10 +62,10 @@ namespace Umbraco.Core.Persistence.Repositories
             }
         }
 
-        protected override IEnumerable<DataTypeDefinition> PerformGetByQuery(IQuery<DataTypeDefinition> query)
+        protected override IEnumerable<IDataTypeDefinition> PerformGetByQuery(IQuery<IDataTypeDefinition> query)
         {
             var sqlClause = GetBaseQuery(false);
-            var translator = new SqlTranslator<DataTypeDefinition>(sqlClause, query);
+            var translator = new SqlTranslator<IDataTypeDefinition>(sqlClause, query);
             var sql = translator.Translate();
 
             var dataTypeDtos = Database.Fetch<DataTypeDto, NodeDto>(sql);
@@ -110,10 +110,10 @@ namespace Umbraco.Core.Persistence.Repositories
         #endregion
 
         #region Unit of Work Implementation
-        
-        protected override void PersistNewItem(DataTypeDefinition entity)
+
+        protected override void PersistNewItem(IDataTypeDefinition entity)
         {
-            entity.AddingEntity();
+            ((DataTypeDefinition)entity).AddingEntity();
 
             var factory = new DataTypeDefinitionFactory(NodeObjectTypeId);
             var dto = factory.BuildDto(entity);
@@ -144,13 +144,13 @@ namespace Umbraco.Core.Persistence.Repositories
 
             Database.Insert(dto);
 
-            entity.ResetDirtyProperties();
+            ((DataTypeDefinition)entity).ResetDirtyProperties();
         }
 
-        protected override void PersistUpdatedItem(DataTypeDefinition entity)
+        protected override void PersistUpdatedItem(IDataTypeDefinition entity)
         {
             //Updates Modified date and Version Guid
-            entity.UpdatingEntity();
+            ((DataTypeDefinition)entity).UpdatingEntity();
 
             var factory = new DataTypeDefinitionFactory(NodeObjectTypeId);
             //Look up DataTypeDefinition entry to get Primary for updating the DTO
@@ -163,10 +163,10 @@ namespace Umbraco.Core.Persistence.Repositories
             Database.Update(nodeDto);
             Database.Update(dto);
 
-            entity.ResetDirtyProperties();
+            ((DataTypeDefinition)entity).ResetDirtyProperties();
         }
 
-        protected override void PersistDeletedItem(DataTypeDefinition entity)
+        protected override void PersistDeletedItem(IDataTypeDefinition entity)
         {
             //Remove Notifications
             Database.Delete<User2NodeNotifyDto>("WHERE nodeId = @Id", new { Id = entity.Id });
diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs
index abbf8c95a0..a63e531d90 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs
@@ -1,9 +1,16 @@
-using Umbraco.Core.Models;
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+using Umbraco.Core.Persistence.Querying;
 
 namespace Umbraco.Core.Persistence.Repositories
 {
     public interface IContentTypeRepository : IRepositoryQueryable<int, IContentType>
     {
-         
+        /// <summary>
+        /// Gets all entities of the specified <see cref="PropertyType"/> query
+        /// </summary>
+        /// <param name="query"></param>
+        /// <returns>An enumerable list of <see cref="IContentType"/> objects</returns>
+        IEnumerable<IContentType> GetByQuery(IQuery<PropertyType> query);
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDataTypeDefinitionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDataTypeDefinitionRepository.cs
index 01e3faaa9a..7a39a2cdc1 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDataTypeDefinitionRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDataTypeDefinitionRepository.cs
@@ -2,7 +2,7 @@
 
 namespace Umbraco.Core.Persistence.Repositories
 {
-    public interface IDataTypeDefinitionRepository : IRepositoryQueryable<int, DataTypeDefinition>
+    public interface IDataTypeDefinitionRepository : IRepositoryQueryable<int, IDataTypeDefinition>
     {
          
     }
diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaTypeRepository.cs
index e92cb3fecf..54220e0b59 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaTypeRepository.cs
@@ -1,9 +1,16 @@
-using Umbraco.Core.Models;
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+using Umbraco.Core.Persistence.Querying;
 
 namespace Umbraco.Core.Persistence.Repositories
 {
     public interface IMediaTypeRepository : IRepositoryQueryable<int, IMediaType>
     {
-         
+        /// <summary>
+        /// Gets all entities of the specified <see cref="PropertyType"/> query
+        /// </summary>
+        /// <param name="query"></param>
+        /// <returns>An enumerable list of <see cref="IContentType"/> objects</returns>
+        IEnumerable<IMediaType> GetByQuery(IQuery<PropertyType> query);
     }
 }
\ No newline at end of file
diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepositoryQueryable.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepositoryQueryable.cs
index 9174c1caf0..9cea6ce7bc 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepositoryQueryable.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepositoryQueryable.cs
@@ -13,7 +13,7 @@ namespace Umbraco.Core.Persistence.Repositories
         where TEntity : IAggregateRoot
     {
         /// <summary>
-        /// Gets all entities of the spefified type and query
+        /// Gets all entities of the specified type and query
         /// </summary>
         /// <param name="query"></param>
         /// <returns></returns>
diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
index ed5a167b26..2271085696 100644
--- a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs
@@ -88,6 +88,15 @@ namespace Umbraco.Core.Persistence.Repositories
 
         #endregion
 
+        public IEnumerable<IMediaType> GetByQuery(IQuery<PropertyType> query)
+        {
+            var ints = PerformGetByQuery(query);
+            foreach (var i in ints)
+            {
+                yield return Get(i);
+            }
+        }
+
         #region Overrides of PetaPocoRepositoryBase<int,IMedia>
 
         protected override Sql GetBaseQuery(bool isCount)
diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj
index 3b6b7fcb1e..7940527a46 100644
--- a/src/Umbraco.Core/Umbraco.Core.csproj
+++ b/src/Umbraco.Core/Umbraco.Core.csproj
@@ -87,6 +87,7 @@
     <Compile Include="Models\DictionaryItem.cs" />
     <Compile Include="Models\DictionaryTranslation.cs" />
     <Compile Include="Models\File.cs" />
+    <Compile Include="Models\IDataTypeDefinition.cs" />
     <Compile Include="Models\IFile.cs" />
     <Compile Include="Models\Language.cs" />
     <Compile Include="Models\Media.cs" />
@@ -140,6 +141,8 @@
     <Compile Include="Persistence\Mappers\LanguageMapper.cs" />
     <Compile Include="Persistence\Mappers\MediaMapper.cs" />
     <Compile Include="Persistence\Mappers\ModelDtoMapper.cs" />
+    <Compile Include="Persistence\Mappers\PropertyGroupMapper.cs" />
+    <Compile Include="Persistence\Mappers\PropertyTypeMapper.cs" />
     <Compile Include="Persistence\Mappers\RelationMapper.cs" />
     <Compile Include="Persistence\Mappers\RelationTypeMapper.cs" />
     <Compile Include="Persistence\Migrations\Initial\BaseDataCreation.cs" />
diff --git a/src/Umbraco.Tests/Persistence/Mappers/PropertyGroupMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/PropertyGroupMapperTest.cs
new file mode 100644
index 0000000000..1fad331023
--- /dev/null
+++ b/src/Umbraco.Tests/Persistence/Mappers/PropertyGroupMapperTest.cs
@@ -0,0 +1,62 @@
+using NUnit.Framework;
+using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Tests.Persistence.Mappers
+{
+    [TestFixture]
+    public class PropertyGroupMapperTest
+    {
+        [Test]
+        public void Can_Map_Id_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyGroupMapper.Instance.Map("Id");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsPropertyTypeGroup].[id]"));
+        }
+
+        [Test]
+        public void Can_Map_ParentId_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyGroupMapper.Instance.Map("ParentId");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsPropertyTypeGroup].[parentGroupId]"));
+        }
+
+        [Test]
+        public void Can_Map_SortOrder_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyGroupMapper.Instance.Map("SortOrder");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsPropertyTypeGroup].[sortorder]"));
+        }
+
+        [Test]
+        public void Can_Map_Name_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyGroupMapper.Instance.Map("Name");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsPropertyTypeGroup].[text]"));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Tests/Persistence/Mappers/PropertyTypeMapperTest.cs b/src/Umbraco.Tests/Persistence/Mappers/PropertyTypeMapperTest.cs
new file mode 100644
index 0000000000..a45cf065e2
--- /dev/null
+++ b/src/Umbraco.Tests/Persistence/Mappers/PropertyTypeMapperTest.cs
@@ -0,0 +1,88 @@
+using NUnit.Framework;
+using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Tests.Persistence.Mappers
+{
+    [TestFixture]
+    public class PropertyTypeMapperTest
+    {
+        [Test]
+        public void Can_Map_Id_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyTypeMapper.Instance.Map("Id");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsPropertyType].[id]"));
+        }
+
+        [Test]
+        public void Can_Map_Alias_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyTypeMapper.Instance.Map("Alias");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsPropertyType].[Alias]"));
+        }
+
+        [Test]
+        public void Can_Map_DataTypeId_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyTypeMapper.Instance.Map("DataTypeId");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsPropertyType].[dataTypeId]"));
+        }
+
+        [Test]
+        public void Can_Map_SortOrder_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyTypeMapper.Instance.Map("SortOrder");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsPropertyType].[sortOrder]"));
+        }
+
+        [Test]
+        public void Can_Map_DataTypeControlId_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyTypeMapper.Instance.Map("DataTypeControlId");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsDataType].[controlId]"));
+        }
+
+        [Test]
+        public void Can_Map_DataTypeDatabaseType_Property()
+        {
+            // Arrange
+            SyntaxConfig.SqlSyntaxProvider = SqlCeSyntax.Provider;
+
+            // Act
+            string column = PropertyTypeMapper.Instance.Map("DataTypeDatabaseType");
+
+            // Assert
+            Assert.That(column, Is.EqualTo("[cmsDataType].[dbType]"));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Tests/Persistence/RepositoryResolverTests.cs b/src/Umbraco.Tests/Persistence/RepositoryResolverTests.cs
index 88d3ac3d8b..6b291418f8 100644
--- a/src/Umbraco.Tests/Persistence/RepositoryResolverTests.cs
+++ b/src/Umbraco.Tests/Persistence/RepositoryResolverTests.cs
@@ -81,7 +81,7 @@ namespace Umbraco.Tests.Persistence
             var uow = new PetaPocoUnitOfWork();
 
             // Act
-            var repository = RepositoryResolver.ResolveByType<IDataTypeDefinitionRepository, DataTypeDefinition, int>(uow);
+            var repository = RepositoryResolver.ResolveByType<IDataTypeDefinitionRepository, IDataTypeDefinition, int>(uow);
 
             // Assert
             Assert.That(repository, Is.Not.Null);
diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj
index 553f0679ca..048cd5a5ac 100644
--- a/src/Umbraco.Tests/Umbraco.Tests.csproj
+++ b/src/Umbraco.Tests/Umbraco.Tests.csproj
@@ -103,6 +103,8 @@
     <Compile Include="Persistence\Mappers\DictionaryTranslationMapperTest.cs" />
     <Compile Include="Persistence\Mappers\LanguageMapperTest.cs" />
     <Compile Include="Persistence\Mappers\MediaMapperTest.cs" />
+    <Compile Include="Persistence\Mappers\PropertyGroupMapperTest.cs" />
+    <Compile Include="Persistence\Mappers\PropertyTypeMapperTest.cs" />
     <Compile Include="Persistence\Mappers\RelationMapperTest.cs" />
     <Compile Include="Persistence\Mappers\RelationTypeMapperTest.cs" />
     <Compile Include="Persistence\MySqlDatabaseCreationTest.cs" />
diff --git a/src/Umbraco.Web/Services/DataTypeService.cs b/src/Umbraco.Web/Services/DataTypeService.cs
new file mode 100644
index 0000000000..8e71d16469
--- /dev/null
+++ b/src/Umbraco.Web/Services/DataTypeService.cs
@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Umbraco.Core;
+using Umbraco.Core.Models;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.Repositories;
+using Umbraco.Core.Persistence.UnitOfWork;
+using umbraco.interfaces;
+
+namespace Umbraco.Web.Services
+{
+    /// <summary>
+    /// Represents the DataType Service, which is an easy access to operations involving <see cref="IDataType"/> and <see cref="IDataTypeDefinition"/>
+    /// </summary>
+    public class DataTypeService : IDataTypeService
+    {
+        private readonly IUnitOfWorkProvider _provider;
+
+        public DataTypeService() : this(new PetaPocoUnitOfWorkProvider())
+        {
+        }
+
+        public DataTypeService(IUnitOfWorkProvider provider)
+        {
+            _provider = provider;
+        }
+
+        /// <summary>
+        /// Gets a <see cref="IDataTypeDefinition"/> by its Id
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IDataTypeDefinition"/></param>
+        /// <returns><see cref="IDataTypeDefinition"/></returns>
+        public IDataTypeDefinition GetDataTypeDefinitionById(int id)
+        {
+            var unitOfWork = _provider.GetUnitOfWork();
+            var repository = RepositoryResolver.ResolveByType<IDataTypeDefinitionRepository, IDataTypeDefinition, int>(unitOfWork);
+            return repository.Get(id);
+        }
+
+        /// <summary>
+        /// Gets a <see cref="IDataTypeDefinition"/> by its control Id
+        /// </summary>
+        /// <param name="id">Id of the DataType control</param>
+        /// <returns><see cref="IDataTypeDefinition"/></returns>
+        public IDataTypeDefinition GetDataTypeDefinitionById(Guid id)
+        {
+            var unitOfWork = _provider.GetUnitOfWork();
+            var repository = RepositoryResolver.ResolveByType<IDataTypeDefinitionRepository, IDataTypeDefinition, int>(unitOfWork);
+
+            var query = Query<IDataTypeDefinition>.Builder.Where(x => x.ControlId == id);
+            var definitions = repository.GetByQuery(query);
+
+            return definitions.FirstOrDefault();
+        }
+
+        /// <summary>
+        /// Gets all <see cref="IDataTypeDefinition"/> objects or those with the ids passed in
+        /// </summary>
+        /// <param name="ids">Optional array of Ids</param>
+        /// <returns>An enumerable list of <see cref="IDataTypeDefinition"/> objects</returns>
+        public IEnumerable<IDataTypeDefinition> GetAllDataTypeDefinitions(params int[] ids)
+        {
+            var unitOfWork = _provider.GetUnitOfWork();
+            var repository = RepositoryResolver.ResolveByType<IDataTypeDefinitionRepository, IDataTypeDefinition, int>(unitOfWork);
+            return repository.GetAll(ids);
+        }
+
+        /// <summary>
+        /// Saves an <see cref="IDataTypeDefinition"/>
+        /// </summary>
+        /// <param name="dataTypeDefinition"><see cref="IDataTypeDefinition"/> to save</param>
+        /// <param name="userId">Id of the user issueing the save</param>
+        public void Save(IDataTypeDefinition dataTypeDefinition, int userId)
+        {
+            var unitOfWork = _provider.GetUnitOfWork();
+            var repository = RepositoryResolver.ResolveByType<IDataTypeDefinitionRepository, IDataTypeDefinition, int>(unitOfWork);
+            repository.AddOrUpdate(dataTypeDefinition);
+            unitOfWork.Commit();
+        }
+
+        /// <summary>
+        /// Deletes an <see cref="IDataTypeDefinition"/>
+        /// </summary>
+        /// <remarks>
+        /// Please note that deleting a <see cref="IDataTypeDefinition"/> will remove
+        /// all the <see cref="PropertyType"/> data that references this <see cref="IDataTypeDefinition"/>.
+        /// </remarks>
+        /// <param name="dataTypeDefinition"><see cref="IDataTypeDefinition"/> to delete</param>
+        /// <param name="userId">Id of the user issueing the deletion</param>
+        public void Delete(IDataTypeDefinition dataTypeDefinition, int userId)
+        {
+            var unitOfWork = _provider.GetUnitOfWork();
+            
+            //Find ContentTypes using this IDataTypeDefinition on a PropertyType
+            var contentTypeRepository = RepositoryResolver.ResolveByType<IContentTypeRepository, IContentType, int>(unitOfWork);
+            var query = Query<PropertyType>.Builder.Where(x => x.DataTypeId == dataTypeDefinition.Id);
+            var contentTypes = contentTypeRepository.GetByQuery(query);
+
+            //Loop through the list of results and remove the PropertyTypes that references the DataTypeDefinition that is being deleted
+            foreach (var contentType in contentTypes)
+            {
+                if(contentType == null) continue;
+
+                foreach (var group in contentType.PropertyGroups)
+                {
+                    var types = group.PropertyTypes.Where(x => x.DataTypeId == dataTypeDefinition.Id);
+                    foreach (var propertyType in types)
+                    {
+                        group.PropertyTypes.Remove(propertyType);
+                    }
+                }
+
+                contentTypeRepository.AddOrUpdate(contentType);
+            }
+
+            var repository = RepositoryResolver.ResolveByType<IDataTypeDefinitionRepository, IDataTypeDefinition, int>(unitOfWork);
+            repository.Delete(dataTypeDefinition);
+            unitOfWork.Commit();
+        }
+
+        /// <summary>
+        /// Retrieves the IDataType specified by it's unique ID
+        /// </summary>
+        /// <param name="id">Id of the DataType, which corresponds to the Guid Id of the control</param>
+        /// <returns><see cref="IDataType"/> object</returns>
+        public IDataType GetDataTypeById(Guid id)
+        {
+            return DataTypesResolver.Current.GetById(id);
+        }
+
+        /// <summary>
+        /// Retrieve a complete list of all registered IDataType's
+        /// </summary>
+        /// <returns>An enumerable list of <see cref="IDataType"/> objects</returns>
+        public IEnumerable<IDataType> GetAllDataTypes()
+        {
+            return DataTypesResolver.Current.DataTypes;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Services/IDataTypeService.cs b/src/Umbraco.Web/Services/IDataTypeService.cs
new file mode 100644
index 0000000000..d16f62552c
--- /dev/null
+++ b/src/Umbraco.Web/Services/IDataTypeService.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+using umbraco.interfaces;
+
+namespace Umbraco.Web.Services
+{
+    /// <summary>
+    /// Defines the DataType Service, which is an easy access to operations involving <see cref="IDataType"/> and <see cref="IDataTypeDefinition"/>
+    /// </summary>
+    public interface IDataTypeService : IService
+    {
+        /// <summary>
+        /// Gets a <see cref="IDataTypeDefinition"/> by its Id
+        /// </summary>
+        /// <param name="id">Id of the <see cref="IDataTypeDefinition"/></param>
+        /// <returns><see cref="IDataTypeDefinition"/></returns>
+        IDataTypeDefinition GetDataTypeDefinitionById(int id);
+
+        /// <summary>
+        /// Gets a <see cref="IDataTypeDefinition"/> by its control Id
+        /// </summary>
+        /// <param name="id">Id of the DataType control</param>
+        /// <returns><see cref="IDataTypeDefinition"/></returns>
+        IDataTypeDefinition GetDataTypeDefinitionById(Guid id);
+
+        /// <summary>
+        /// Gets all <see cref="IDataTypeDefinition"/> objects or those with the ids passed in
+        /// </summary>
+        /// <param name="ids">Optional array of Ids</param>
+        /// <returns>An enumerable list of <see cref="IDataTypeDefinition"/> objects</returns>
+        IEnumerable<IDataTypeDefinition> GetAllDataTypeDefinitions(params int[] ids);
+
+        /// <summary>
+        /// Saves an <see cref="IDataTypeDefinition"/>
+        /// </summary>
+        /// <param name="dataTypeDefinition"><see cref="IDataTypeDefinition"/> to save</param>
+        /// <param name="userId">Id of the user issueing the save</param>
+        void Save(IDataTypeDefinition dataTypeDefinition, int userId);
+
+        /// <summary>
+        /// Deletes an <see cref="IDataTypeDefinition"/>
+        /// </summary>
+        /// <remarks>
+        /// Please note that deleting a <see cref="IDataTypeDefinition"/> will remove
+        /// all the <see cref="PropertyType"/> data that references this <see cref="IDataTypeDefinition"/>.
+        /// </remarks>
+        /// <param name="dataTypeDefinition"><see cref="IDataTypeDefinition"/> to delete</param>
+        /// <param name="userId">Id of the user issueing the deletion</param>
+        void Delete(IDataTypeDefinition dataTypeDefinition, int userId);
+
+        /// <summary>
+        /// Retrieves the IDataType specified by it's unique ID
+        /// </summary>
+        /// <param name="id">Id of the DataType, which corresponds to the Guid Id of the control</param>
+        /// <returns><see cref="IDataType"/> object</returns>
+        IDataType GetDataTypeById(Guid id);
+
+        /// <summary>
+        /// Retrieve a complete list of all registered IDataType's
+        /// </summary>
+        /// <returns>An enumerable list of <see cref="IDataType"/> objects</returns>
+        IEnumerable<IDataType> GetAllDataTypes();
+    }
+}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Services/UmbracoContextExtensions.cs b/src/Umbraco.Web/Services/UmbracoContextExtensions.cs
deleted file mode 100644
index e69f98f762..0000000000
--- a/src/Umbraco.Web/Services/UmbracoContextExtensions.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using System.Collections.Concurrent;
-using Umbraco.Core.Persistence.UnitOfWork;
-using Umbraco.Web.Publishing;
-using Umbraco.Web.Services;
-
-namespace Umbraco.Web
-{
-    /// <summary>
-    /// Service specific extensions for <see cref="UmbracoContext"/>, which provides access to the various services
-    /// </summary>
-    public static class UmbracoContextExtensions
-    {
-        //TODO Add services to a dictionary, so we don't create a new instance each time a service is needed
-        private static readonly ConcurrentDictionary<string, IService> ServiceCache = new ConcurrentDictionary<string, IService>();
-
-        public static IContentService ContentService(this UmbracoContext umbracoContext)
-        {
-            return new ContentService(new PetaPocoUnitOfWorkProvider(), new PublishingStrategy());
-        }
-
-        public static IMediaService MediaService(this UmbracoContext umbracoContext)
-        {
-            return new MediaService(new PetaPocoUnitOfWorkProvider());
-        }
-
-        public static IContentTypeService ContentTypeService(this UmbracoContext umbracoContext)
-        {
-            var contentService = umbracoContext.ContentService();
-            var mediaService = umbracoContext.MediaService();
-            return new ContentTypeService(contentService, mediaService, new PetaPocoUnitOfWorkProvider());
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj
index 2306a102b2..c118c85ba4 100644
--- a/src/Umbraco.Web/Umbraco.Web.csproj
+++ b/src/Umbraco.Web/Umbraco.Web.csproj
@@ -315,12 +315,13 @@
     <Compile Include="Mvc\SurfaceControllerResolver.cs" />
     <Compile Include="Services\ContentService.cs" />
     <Compile Include="Services\ContentTypeService.cs" />
+    <Compile Include="Services\DataTypeService.cs" />
     <Compile Include="Services\IContentService.cs" />
     <Compile Include="Services\IContentTypeService.cs" />
+    <Compile Include="Services\IDataTypeService.cs" />
     <Compile Include="Services\IMediaService.cs" />
     <Compile Include="Services\IService.cs" />
     <Compile Include="Services\MediaService.cs" />
-    <Compile Include="Services\UmbracoContextExtensions.cs" />
     <Compile Include="Templates\TemplateUtilities.cs" />
     <Compile Include="umbraco.presentation\Default.aspx.cs">
       <SubType>ASPXCodeBehind</SubType>