diff --git a/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs b/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs
index 71d53e9167..84b63f6b0f 100644
--- a/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs
+++ b/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs
@@ -69,7 +69,123 @@ namespace Umbraco.Tests.Models.Mapping
                 entityMapper.ConfigureMappings(configuration, appContext);
             });
         }
-        
+
+        [Test]
+        public void MemberTypeSave_To_IMemberType()
+        {
+            //Arrange
+
+            // setup the mocks to return the data we want to test against...
+
+            _dataTypeService.Setup(x => x.GetDataTypeDefinitionById(It.IsAny<int>()))
+                .Returns(Mock.Of<IDataTypeDefinition>(
+                    definition =>
+                        definition.Id == 555
+                        && definition.PropertyEditorAlias == "myPropertyType"
+                        && definition.DatabaseType == DataTypeDatabaseType.Nvarchar));
+
+            var display = CreateMemberTypeSave();
+
+            //Act
+
+            var result = Mapper.Map<IMemberType>(display);
+
+            //Assert
+
+            Assert.AreEqual(display.Alias, result.Alias);
+            Assert.AreEqual(display.Description, result.Description);
+            Assert.AreEqual(display.Icon, result.Icon);
+            Assert.AreEqual(display.Id, result.Id);
+            Assert.AreEqual(display.Name, result.Name);
+            Assert.AreEqual(display.ParentId, result.ParentId);
+            Assert.AreEqual(display.Path, result.Path);
+            Assert.AreEqual(display.Thumbnail, result.Thumbnail);
+            Assert.AreEqual(display.IsContainer, result.IsContainer);
+            Assert.AreEqual(display.AllowAsRoot, result.AllowedAsRoot);
+            Assert.AreEqual(display.CreateDate, result.CreateDate);
+            Assert.AreEqual(display.UpdateDate, result.UpdateDate);
+
+            //TODO: Now we need to assert all of the more complicated parts
+            Assert.AreEqual(display.Groups.Count(), result.PropertyGroups.Count);
+            for (var i = 0; i < display.Groups.Count(); i++)
+            {
+                Assert.AreEqual(display.Groups.ElementAt(i).Id, result.PropertyGroups.ElementAt(i).Id);
+                Assert.AreEqual(display.Groups.ElementAt(i).Name, result.PropertyGroups.ElementAt(i).Name);
+                var propTypes = display.Groups.ElementAt(i).Properties;
+                Assert.AreEqual(propTypes.Count(), result.PropertyTypes.Count());
+                for (var j = 0; j < propTypes.Count(); j++)
+                {
+                    Assert.AreEqual(propTypes.ElementAt(j).Id, result.PropertyTypes.ElementAt(j).Id);
+                    Assert.AreEqual(propTypes.ElementAt(j).DataTypeId, result.PropertyTypes.ElementAt(j).DataTypeDefinitionId);
+                    Assert.AreEqual(propTypes.ElementAt(j).MemberCanViewProperty, result.MemberCanViewProperty(result.PropertyTypes.ElementAt(j).Alias));
+                    Assert.AreEqual(propTypes.ElementAt(j).MemberCanEditProperty, result.MemberCanEditProperty(result.PropertyTypes.ElementAt(j).Alias));
+                }
+            }
+
+            Assert.AreEqual(display.AllowedContentTypes.Count(), result.AllowedContentTypes.Count());
+            for (var i = 0; i < display.AllowedContentTypes.Count(); i++)
+            {
+                Assert.AreEqual(display.AllowedContentTypes.ElementAt(i), result.AllowedContentTypes.ElementAt(i).Id.Value);
+            }
+        }
+
+        [Test]
+        public void MediaTypeSave_To_IMediaType()
+        {
+            //Arrange
+
+            // setup the mocks to return the data we want to test against...
+
+            _dataTypeService.Setup(x => x.GetDataTypeDefinitionById(It.IsAny<int>()))
+                .Returns(Mock.Of<IDataTypeDefinition>(
+                    definition =>
+                        definition.Id == 555
+                        && definition.PropertyEditorAlias == "myPropertyType"
+                        && definition.DatabaseType == DataTypeDatabaseType.Nvarchar));            
+
+            var display = CreateMediaTypeSave();
+
+            //Act
+
+            var result = Mapper.Map<IMediaType>(display);
+
+            //Assert
+
+            Assert.AreEqual(display.Alias, result.Alias);
+            Assert.AreEqual(display.Description, result.Description);
+            Assert.AreEqual(display.Icon, result.Icon);
+            Assert.AreEqual(display.Id, result.Id);
+            Assert.AreEqual(display.Name, result.Name);
+            Assert.AreEqual(display.ParentId, result.ParentId);
+            Assert.AreEqual(display.Path, result.Path);
+            Assert.AreEqual(display.Thumbnail, result.Thumbnail);
+            Assert.AreEqual(display.IsContainer, result.IsContainer);
+            Assert.AreEqual(display.AllowAsRoot, result.AllowedAsRoot);
+            Assert.AreEqual(display.CreateDate, result.CreateDate);
+            Assert.AreEqual(display.UpdateDate, result.UpdateDate);
+
+            //TODO: Now we need to assert all of the more complicated parts
+            Assert.AreEqual(display.Groups.Count(), result.PropertyGroups.Count);
+            for (var i = 0; i < display.Groups.Count(); i++)
+            {
+                Assert.AreEqual(display.Groups.ElementAt(i).Id, result.PropertyGroups.ElementAt(i).Id);
+                Assert.AreEqual(display.Groups.ElementAt(i).Name, result.PropertyGroups.ElementAt(i).Name);
+                var propTypes = display.Groups.ElementAt(i).Properties;
+                Assert.AreEqual(propTypes.Count(), result.PropertyTypes.Count());
+                for (var j = 0; j < propTypes.Count(); j++)
+                {
+                    Assert.AreEqual(propTypes.ElementAt(j).Id, result.PropertyTypes.ElementAt(j).Id);
+                    Assert.AreEqual(propTypes.ElementAt(j).DataTypeId, result.PropertyTypes.ElementAt(j).DataTypeDefinitionId);
+                }
+            }            
+
+            Assert.AreEqual(display.AllowedContentTypes.Count(), result.AllowedContentTypes.Count());
+            for (var i = 0; i < display.AllowedContentTypes.Count(); i++)
+            {
+                Assert.AreEqual(display.AllowedContentTypes.ElementAt(i), result.AllowedContentTypes.ElementAt(i).Id.Value);
+            }
+        }
+
         [Test]
         public void ContentTypeSave_To_IContentType()
         {
@@ -144,6 +260,33 @@ namespace Umbraco.Tests.Models.Mapping
             }
         }
 
+        [Test]
+        public void MediaTypeSave_With_Composition_To_IMediaType()
+        {
+            //Arrange
+
+            // setup the mocks to return the data we want to test against...
+
+            _dataTypeService.Setup(x => x.GetDataTypeDefinitionById(It.IsAny<int>()))
+                .Returns(Mock.Of<IDataTypeDefinition>(
+                    definition =>
+                        definition.Id == 555
+                        && definition.PropertyEditorAlias == "myPropertyType"
+                        && definition.DatabaseType == DataTypeDatabaseType.Nvarchar));
+
+
+            var display = CreateCompositionMediaTypeSave();
+
+            //Act
+
+            var result = Mapper.Map<IMediaType>(display);
+
+            //Assert
+
+            //TODO: Now we need to assert all of the more complicated parts
+            Assert.AreEqual(display.Groups.Count(x => x.Inherited == false), result.PropertyGroups.Count);
+        }
+
         [Test]
         public void ContentTypeSave_With_Composition_To_IContentType()
         {
@@ -171,6 +314,71 @@ namespace Umbraco.Tests.Models.Mapping
             Assert.AreEqual(display.Groups.Count(x => x.Inherited == false), result.PropertyGroups.Count);
         }
 
+        [Test]
+        public void IMediaType_To_MediaTypeDisplay()
+        {
+            //Arrange
+
+            // setup the mocks to return the data we want to test against...
+
+            // for any call to GetPreValuesCollectionByDataTypeId just return an empty dictionary for now
+            // TODO: but we'll need to change this to return some pre-values to test the mappings
+            _dataTypeService.Setup(x => x.GetPreValuesCollectionByDataTypeId(It.IsAny<int>()))
+                .Returns(new PreValueCollection(new Dictionary<string, PreValue>()));
+
+            //return a textbox property editor for any requested editor by alias
+            _propertyEditorResolver.Setup(resolver => resolver.GetByAlias(It.IsAny<string>()))
+                .Returns(new TextboxPropertyEditor());
+            //for testing, just return a list of whatever property editors we want
+            _propertyEditorResolver.Setup(resolver => resolver.PropertyEditors)
+                .Returns(new[] { new TextboxPropertyEditor() });
+
+            var mediaType = MockedContentTypes.CreateImageMediaType();
+            MockedContentTypes.EnsureAllIds(mediaType, 8888);
+
+            //Act
+
+            var result = Mapper.Map<MediaTypeDisplay>(mediaType);
+
+            //Assert
+
+            Assert.AreEqual(mediaType.Alias, result.Alias);
+            Assert.AreEqual(mediaType.Description, result.Description);
+            Assert.AreEqual(mediaType.Icon, result.Icon);
+            Assert.AreEqual(mediaType.Id, result.Id);
+            Assert.AreEqual(mediaType.Name, result.Name);
+            Assert.AreEqual(mediaType.ParentId, result.ParentId);
+            Assert.AreEqual(mediaType.Path, result.Path);
+            Assert.AreEqual(mediaType.Thumbnail, result.Thumbnail);
+            Assert.AreEqual(mediaType.IsContainer, result.IsContainer);
+            Assert.AreEqual(mediaType.CreateDate, result.CreateDate);
+            Assert.AreEqual(mediaType.UpdateDate, result.UpdateDate);
+
+            //TODO: Now we need to assert all of the more complicated parts
+
+            Assert.AreEqual(mediaType.PropertyGroups.Count(), result.Groups.Count());
+            for (var i = 0; i < mediaType.PropertyGroups.Count(); i++)
+            {
+                Assert.AreEqual(mediaType.PropertyGroups.ElementAt(i).Id, result.Groups.ElementAt(i).Id);
+                Assert.AreEqual(mediaType.PropertyGroups.ElementAt(i).Name, result.Groups.ElementAt(i).Name);
+                var propTypes = mediaType.PropertyGroups.ElementAt(i).PropertyTypes;
+
+                Assert.AreEqual(propTypes.Count(), result.Groups.ElementAt(i).Properties.Count());
+                for (var j = 0; j < propTypes.Count(); j++)
+                {
+                    Assert.AreEqual(propTypes.ElementAt(j).Id, result.Groups.ElementAt(i).Properties.ElementAt(j).Id);
+                    Assert.AreEqual(propTypes.ElementAt(j).DataTypeDefinitionId, result.Groups.ElementAt(i).Properties.ElementAt(j).DataTypeId);
+                }
+            }
+            
+            Assert.AreEqual(mediaType.AllowedContentTypes.Count(), result.AllowedContentTypes.Count());
+            for (var i = 0; i < mediaType.AllowedContentTypes.Count(); i++)
+            {
+                Assert.AreEqual(mediaType.AllowedContentTypes.ElementAt(i).Id.Value, result.AllowedContentTypes.ElementAt(i));
+            }
+
+        }
+
         [Test]
         public void IContentType_To_ContentTypeDisplay()
         {
@@ -243,6 +451,75 @@ namespace Umbraco.Tests.Models.Mapping
 
         }
 
+        [Test]
+        public void MemberPropertyGroupBasic_To_MemberPropertyGroup()
+        {
+            _dataTypeService.Setup(x => x.GetDataTypeDefinitionById(It.IsAny<int>()))
+                .Returns(new DataTypeDefinition("test"));
+
+            var basic = new PropertyGroupBasic<MemberPropertyTypeBasic>
+            {
+                Id = 222,
+                Name = "Group 1",
+                SortOrder = 1,
+                Properties = new[]
+                {
+                    new MemberPropertyTypeBasic()
+                    {
+                        MemberCanEditProperty = true,
+                        MemberCanViewProperty = true,
+                        Id = 33,
+                        SortOrder = 1,
+                        Alias = "prop1",
+                        Description = "property 1",
+                        DataTypeId = 99,
+                        GroupId = 222,
+                        Label = "Prop 1",
+                        Validation = new PropertyTypeValidation()
+                        {
+                            Mandatory = true,
+                            Pattern = null
+                        }
+                    },
+                    new MemberPropertyTypeBasic()
+                    {
+                        MemberCanViewProperty = false,
+                        MemberCanEditProperty = false,
+                        Id = 34,
+                        SortOrder = 2,
+                        Alias = "prop2",
+                        Description = "property 2",
+                        DataTypeId = 99,
+                        GroupId = 222,
+                        Label = "Prop 2",
+                        Validation = new PropertyTypeValidation()
+                        {
+                            Mandatory = false,
+                            Pattern = null
+                        }
+                    },
+                }
+            };
+
+            var contentType = new MemberTypeSave
+            {
+                Id = 0,
+                ParentId = -1,
+                Alias = "alias",
+                Groups = new[] { basic }
+            };
+
+            // proper group properties mapping takes place when mapping the content type,
+            // not when mapping the group - because of inherited properties and such
+            //var result = Mapper.Map<PropertyGroup>(basic);
+            var result = Mapper.Map<IMemberType>(contentType).PropertyGroups[0];
+
+            Assert.AreEqual(basic.Name, result.Name);
+            Assert.AreEqual(basic.Id, result.Id);
+            Assert.AreEqual(basic.SortOrder, result.SortOrder);
+            Assert.AreEqual(basic.Properties.Count(), result.PropertyTypes.Count());
+        }
+
         [Test]
         public void PropertyGroupBasic_To_PropertyGroup()
         {
@@ -309,6 +586,40 @@ namespace Umbraco.Tests.Models.Mapping
             Assert.AreEqual(basic.Properties.Count(), result.PropertyTypes.Count());
         }
 
+        [Test]
+        public void MemberPropertyTypeBasic_To_PropertyType()
+        {
+            _dataTypeService.Setup(x => x.GetDataTypeDefinitionById(It.IsAny<int>()))
+                .Returns(new DataTypeDefinition("test"));
+
+            var basic = new MemberPropertyTypeBasic()
+            {
+                Id = 33,
+                SortOrder = 1,
+                Alias = "prop1",
+                Description = "property 1",
+                DataTypeId = 99,
+                GroupId = 222,
+                Label = "Prop 1",
+                Validation = new PropertyTypeValidation()
+                {
+                    Mandatory = true,
+                    Pattern = "xyz"
+                }
+            };
+
+            var result = Mapper.Map<PropertyType>(basic);
+
+            Assert.AreEqual(basic.Id, result.Id);
+            Assert.AreEqual(basic.SortOrder, result.SortOrder);
+            Assert.AreEqual(basic.Alias, result.Alias);
+            Assert.AreEqual(basic.Description, result.Description);
+            Assert.AreEqual(basic.DataTypeId, result.DataTypeDefinitionId);
+            Assert.AreEqual(basic.Label, result.Name);
+            Assert.AreEqual(basic.Validation.Mandatory, result.Mandatory);
+            Assert.AreEqual(basic.Validation.Pattern, result.ValidationRegExp);
+        }
+
         [Test]
         public void PropertyTypeBasic_To_PropertyType()
         {
@@ -343,6 +654,109 @@ namespace Umbraco.Tests.Models.Mapping
             Assert.AreEqual(basic.Validation.Pattern, result.ValidationRegExp);
         }
 
+        [Test]
+        public void IMemberTypeComposition_To_MemberTypeDisplay()
+        {
+            //Arrange
+
+            // setup the mocks to return the data we want to test against...
+
+            // for any call to GetPreValuesCollectionByDataTypeId just return an empty dictionary for now
+            // TODO: but we'll need to change this to return some pre-values to test the mappings
+            _dataTypeService.Setup(x => x.GetPreValuesCollectionByDataTypeId(It.IsAny<int>()))
+                .Returns(new PreValueCollection(new Dictionary<string, PreValue>()));
+
+            _entityService.Setup(x => x.GetObjectType(It.IsAny<int>()))
+                .Returns(UmbracoObjectTypes.DocumentType);
+
+            //return a textbox property editor for any requested editor by alias
+            _propertyEditorResolver.Setup(resolver => resolver.GetByAlias(It.IsAny<string>()))
+                .Returns(new TextboxPropertyEditor());
+            //for testing, just return a list of whatever property editors we want
+            _propertyEditorResolver.Setup(resolver => resolver.PropertyEditors)
+                .Returns(new[] { new TextboxPropertyEditor() });
+
+            var ctMain = MockedContentTypes.CreateSimpleMediaType("parent", "Parent");
+            //not assigned to tab
+            ctMain.AddPropertyType(new PropertyType(Constants.PropertyEditors.TextboxAlias, DataTypeDatabaseType.Ntext)
+            {
+                Alias = "umbracoUrlName",
+                Name = "Slug",
+                Description = "",
+                Mandatory = false,
+                SortOrder = 1,
+                DataTypeDefinitionId = -88
+            });
+            MockedContentTypes.EnsureAllIds(ctMain, 8888);
+            var ctChild1 = MockedContentTypes.CreateSimpleMediaType("child1", "Child 1", ctMain, true);
+            ctChild1.AddPropertyType(new PropertyType(Constants.PropertyEditors.TextboxAlias, DataTypeDatabaseType.Ntext)
+            {
+                Alias = "someProperty",
+                Name = "Some Property",
+                Description = "",
+                Mandatory = false,
+                SortOrder = 1,
+                DataTypeDefinitionId = -88
+            }, "Another tab");
+            MockedContentTypes.EnsureAllIds(ctChild1, 7777);
+            var contentType = MockedContentTypes.CreateSimpleMediaType("child2", "Child 2", ctChild1, true, "CustomGroup");
+            //not assigned to tab
+            contentType.AddPropertyType(new PropertyType(Constants.PropertyEditors.TextboxAlias, DataTypeDatabaseType.Ntext)
+            {
+                Alias = "umbracoUrlAlias",
+                Name = "AltUrl",
+                Description = "",
+                Mandatory = false,
+                SortOrder = 1,
+                DataTypeDefinitionId = -88
+            });
+            MockedContentTypes.EnsureAllIds(contentType, 6666);
+
+
+            //Act
+
+            var result = Mapper.Map<MediaTypeDisplay>(contentType);
+
+            //Assert
+
+            Assert.AreEqual(contentType.Alias, result.Alias);
+            Assert.AreEqual(contentType.Description, result.Description);
+            Assert.AreEqual(contentType.Icon, result.Icon);
+            Assert.AreEqual(contentType.Id, result.Id);
+            Assert.AreEqual(contentType.Name, result.Name);
+            Assert.AreEqual(contentType.ParentId, result.ParentId);
+            Assert.AreEqual(contentType.Path, result.Path);
+            Assert.AreEqual(contentType.Thumbnail, result.Thumbnail);
+            Assert.AreEqual(contentType.IsContainer, result.IsContainer);
+            Assert.AreEqual(contentType.CreateDate, result.CreateDate);
+            Assert.AreEqual(contentType.UpdateDate, result.UpdateDate);
+
+            //TODO: Now we need to assert all of the more complicated parts
+
+            Assert.AreEqual(contentType.CompositionPropertyGroups.Select(x => x.Name).Distinct().Count(), result.Groups.Count(x => x.IsGenericProperties == false));
+            Assert.AreEqual(1, result.Groups.Count(x => x.IsGenericProperties));
+            Assert.AreEqual(contentType.PropertyGroups.Count(), result.Groups.Count(x => x.Inherited == false && x.IsGenericProperties == false));
+
+            var allPropertiesMapped = result.Groups.SelectMany(x => x.Properties).ToArray();
+            var allPropertyIdsMapped = allPropertiesMapped.Select(x => x.Id).ToArray();
+            var allSourcePropertyIds = contentType.CompositionPropertyTypes.Select(x => x.Id).ToArray();
+
+            Assert.AreEqual(contentType.PropertyTypes.Count(), allPropertiesMapped.Count(x => x.Inherited == false));
+            Assert.AreEqual(allPropertyIdsMapped.Count(), allSourcePropertyIds.Count());
+            Assert.IsTrue(allPropertyIdsMapped.ContainsAll(allSourcePropertyIds));
+
+            Assert.AreEqual(2, result.Groups.Count(x => x.ParentTabContentTypes.Any()));
+            Assert.IsTrue(result.Groups.SelectMany(x => x.ParentTabContentTypes).ContainsAll(new[] { ctMain.Id, ctChild1.Id }));
+
+            
+            Assert.AreEqual(contentType.AllowedContentTypes.Count(), result.AllowedContentTypes.Count());
+            for (var i = 0; i < contentType.AllowedContentTypes.Count(); i++)
+            {
+                Assert.AreEqual(contentType.AllowedContentTypes.ElementAt(i).Id.Value, result.AllowedContentTypes.ElementAt(i));
+            }
+
+        }
+
         [Test]
         public void IContentTypeComposition_To_ContentTypeDisplay()
         {
@@ -442,6 +856,99 @@ namespace Umbraco.Tests.Models.Mapping
 
         }
 
+        private MemberTypeSave CreateMemberTypeSave()
+        {
+            return new MemberTypeSave
+            {
+                Alias = "test",
+                AllowAsRoot = true,
+                AllowedContentTypes = new[] { 666, 667 },
+                Description = "hello world",
+                Icon = "tree-icon",
+                Id = 1234,
+                Key = new Guid("8A60656B-3866-46AB-824A-48AE85083070"),
+                Name = "My content type",
+                Path = "-1,1234",
+                ParentId = -1,
+                Thumbnail = "tree-thumb",
+                IsContainer = true,
+                Groups = new[]
+                {
+                    new PropertyGroupBasic<MemberPropertyTypeBasic>()
+                    {                        
+                        Id = 987,
+                        Name = "Tab 1",
+                        SortOrder = 0,
+                        Inherited = false,
+                        Properties = new []
+                        {
+                            new MemberPropertyTypeBasic
+                            {
+                                MemberCanEditProperty = true,
+                                MemberCanViewProperty = true,
+                                Alias = "property1",
+                                Description = "this is property 1",
+                                Inherited = false,
+                                Label = "Property 1",
+                                Validation = new PropertyTypeValidation
+                                {
+                                    Mandatory = false,
+                                    Pattern = ""
+                                },
+                                SortOrder = 0,
+                                DataTypeId = 555
+                            }
+                        }
+                    }
+                }
+            };
+        }
+
+        private MediaTypeSave CreateMediaTypeSave()
+        {
+            return new MediaTypeSave
+            {
+                Alias = "test",
+                AllowAsRoot = true,                
+                AllowedContentTypes = new[] { 666, 667 },
+                Description = "hello world",
+                Icon = "tree-icon",
+                Id = 1234,
+                Key = new Guid("8A60656B-3866-46AB-824A-48AE85083070"),
+                Name = "My content type",
+                Path = "-1,1234",
+                ParentId = -1,
+                Thumbnail = "tree-thumb",
+                IsContainer = true,
+                Groups = new[]
+                {
+                    new PropertyGroupBasic<PropertyTypeBasic>()
+                    {
+                        Id = 987,
+                        Name = "Tab 1",
+                        SortOrder = 0,
+                        Inherited = false,
+                        Properties = new []
+                        {
+                            new PropertyTypeBasic
+                            {
+                                Alias = "property1",
+                                Description = "this is property 1",
+                                Inherited = false,
+                                Label = "Property 1",
+                                Validation = new PropertyTypeValidation
+                                {
+                                    Mandatory = false,
+                                    Pattern = ""
+                                },
+                                SortOrder = 0,
+                                DataTypeId = 555
+                            }
+                        }
+                    }
+                }
+            };
+        }
 
         private DocumentTypeSave CreateContentTypeSave()
         {            
@@ -495,6 +1002,78 @@ namespace Umbraco.Tests.Models.Mapping
             };
         }
 
+        private MediaTypeSave CreateCompositionMediaTypeSave()
+        {
+            return new MediaTypeSave
+            {
+                Alias = "test",
+                AllowAsRoot = true,                
+                AllowedContentTypes = new[] { 666, 667 },
+                Description = "hello world",
+                Icon = "tree-icon",
+                Id = 1234,
+                Key = new Guid("8A60656B-3866-46AB-824A-48AE85083070"),
+                Name = "My content type",
+                Path = "-1,1234",
+                ParentId = -1,
+                Thumbnail = "tree-thumb",
+                IsContainer = true,
+                Groups = new[]
+                {
+                    new PropertyGroupBasic<PropertyTypeBasic>()
+                    {
+                        Id = 987,
+                        Name = "Tab 1",
+                        SortOrder = 0,
+                        Inherited = false,
+                        Properties = new[]
+                        {
+                            new PropertyTypeBasic
+                            {
+                                Alias = "property1",
+                                Description = "this is property 1",
+                                Inherited = false,
+                                Label = "Property 1",
+                                Validation = new PropertyTypeValidation
+                                {
+                                    Mandatory = false,
+                                    Pattern = ""
+                                },
+                                SortOrder = 0,
+                                DataTypeId = 555
+                            }
+                        }
+                    },
+                    new PropertyGroupBasic<PropertyTypeBasic>()
+                    {
+                        Id = 894,
+                        Name = "Tab 2",
+                        SortOrder = 0,
+                        Inherited = true,
+                        Properties = new[]
+                        {
+                            new PropertyTypeBasic
+                            {
+                                Alias = "parentProperty",
+                                Description = "this is a property from the parent",
+                                Inherited = true,
+                                Label = "Parent property",
+                                Validation = new PropertyTypeValidation
+                                {
+                                    Mandatory = false,
+                                    Pattern = ""
+                                },
+                                SortOrder = 0,
+                                DataTypeId = 555
+                            }
+                        }
+
+                    }
+                }
+
+            };
+        }
+
         private DocumentTypeSave CreateCompositionContentTypeSave()
         {
             return new DocumentTypeSave
diff --git a/src/Umbraco.Tests/TestHelpers/Entities/MockedContentTypes.cs b/src/Umbraco.Tests/TestHelpers/Entities/MockedContentTypes.cs
index 3eb0df882a..786053e680 100644
--- a/src/Umbraco.Tests/TestHelpers/Entities/MockedContentTypes.cs
+++ b/src/Umbraco.Tests/TestHelpers/Entities/MockedContentTypes.cs
@@ -431,7 +431,7 @@ namespace Umbraco.Tests.TestHelpers.Entities
             return contentType;
         }
 
-        public static void EnsureAllIds(ContentType contentType, int seedId)
+        public static void EnsureAllIds(ContentTypeCompositionBase contentType, int seedId)
         {
             //ensure everything has ids
             contentType.Id = seedId;
@@ -446,6 +446,7 @@ namespace Umbraco.Tests.TestHelpers.Entities
             }
         }
 
+
         private static string RandomAlias(string alias, bool randomizeAliases)
         {
             if (randomizeAliases)
diff --git a/src/Umbraco.Web/Editors/MediaTypeController.cs b/src/Umbraco.Web/Editors/MediaTypeController.cs
index 6abfb64b16..c2dcc18828 100644
--- a/src/Umbraco.Web/Editors/MediaTypeController.cs
+++ b/src/Umbraco.Web/Editors/MediaTypeController.cs
@@ -157,14 +157,14 @@ namespace Umbraco.Web.Editors
                 : Request.CreateNotificationValidationErrorResponse(result.Exception.Message);
         }
 
-        public ContentTypeCompositionDisplay PostSave(MediaTypeSave contentTypeSave)
+        public MediaTypeDisplay PostSave(MediaTypeSave contentTypeSave)
         {
             var savedCt = PerformPostSave<IMediaType, ContentTypeCompositionDisplay, MediaTypeSave, PropertyTypeBasic>(
                 contentTypeSave:        contentTypeSave,
                 getContentType:         i => Services.ContentTypeService.GetMediaType(i),
                 saveContentType:        type => Services.ContentTypeService.Save(type));
 
-            var display = Mapper.Map<ContentTypeCompositionDisplay>(savedCt);
+            var display = Mapper.Map<MediaTypeDisplay>(savedCt);
 
             display.AddSuccessNotification(
                             Services.TextService.Localize("speechBubbles/contentTypeSavedHeader"),
diff --git a/src/Umbraco.Web/Editors/MemberTypeController.cs b/src/Umbraco.Web/Editors/MemberTypeController.cs
index 5c697e518f..47d0b68496 100644
--- a/src/Umbraco.Web/Editors/MemberTypeController.cs
+++ b/src/Umbraco.Web/Editors/MemberTypeController.cs
@@ -129,7 +129,7 @@ namespace Umbraco.Web.Editors
             return Enumerable.Empty<ContentTypeBasic>();
         }
 
-        public ContentTypeCompositionDisplay PostSave(MemberTypeSave contentTypeSave)
+        public MemberTypeDisplay PostSave(MemberTypeSave contentTypeSave)
         {
             var savedCt = PerformPostSave<IMemberType, ContentTypeCompositionDisplay, MemberTypeSave, MemberPropertyTypeBasic>(
                 contentTypeSave:            contentTypeSave,
@@ -137,7 +137,7 @@ namespace Umbraco.Web.Editors
                 saveContentType:            type => Services.MemberTypeService.Save(type),
                 validateComposition:        false);
 
-            var display = Mapper.Map<ContentTypeCompositionDisplay>(savedCt);
+            var display = Mapper.Map<MemberTypeDisplay>(savedCt);
 
             display.AddSuccessNotification(
                             Services.TextService.Localize("speechBubbles/contentTypeSavedHeader"),
diff --git a/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs b/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs
index bf4acc3c70..847b2ed434 100644
--- a/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs
+++ b/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs
@@ -171,13 +171,13 @@ namespace Umbraco.Web.Models.Mapping
             #region *** Used for mapping on top of an existing display object from a save object ***
 
             config.CreateMap<MemberTypeSave, MemberTypeDisplay>()
-                .MapBaseContentTypeSaveToDisplay<MemberTypeSave, MemberTypeDisplay, MemberPropertyTypeDisplay>();
+                .MapBaseContentTypeSaveToDisplay<MemberTypeSave, MemberPropertyTypeBasic, MemberTypeDisplay, MemberPropertyTypeDisplay>();
 
             config.CreateMap<MediaTypeSave, MediaTypeDisplay>()
-                .MapBaseContentTypeSaveToDisplay<MediaTypeSave, MediaTypeDisplay, PropertyTypeDisplay>();
+                .MapBaseContentTypeSaveToDisplay<MediaTypeSave, PropertyTypeBasic, MediaTypeDisplay, PropertyTypeDisplay>();
             
             config.CreateMap<DocumentTypeSave, DocumentTypeDisplay>()
-                .MapBaseContentTypeSaveToDisplay<DocumentTypeSave, DocumentTypeDisplay, PropertyTypeDisplay>()
+                .MapBaseContentTypeSaveToDisplay<DocumentTypeSave, PropertyTypeBasic, DocumentTypeDisplay, PropertyTypeDisplay>()
                 .ForMember(dto => dto.AllowedTemplates, expression => expression.Ignore())
                 .ForMember(dto => dto.DefaultTemplate, expression => expression.Ignore())
                 .AfterMap((source, dest) =>
@@ -209,27 +209,21 @@ namespace Umbraco.Web.Models.Mapping
                     }
                 });
 
+            //for doc types, media types
             config.CreateMap<PropertyGroupBasic<PropertyTypeBasic>, PropertyGroup>()
-                    .ForMember(dest => dest.Id, map => map.Condition(source => source.Id > 0))
-                    .ForMember(dest => dest.Key, map => map.Ignore())
-                    .ForMember(dest => dest.HasIdentity, map => map.Ignore())
-                    .ForMember(dest => dest.CreateDate, map => map.Ignore())
-                    .ForMember(dest => dest.UpdateDate, map => map.Ignore())
-                    // fixme
-                    // this is basically *replacing* dest properties by a mapped version of
-                    // *every* source properties (including, I guess, inherited properties?)
-                    // also, ContentTypeModelMapperExtensions will map properties *again* so
-                    // this makes little sense - ignore for now
-                    .ForMember(dest => dest.PropertyTypes, map => map.Ignore());
-                    //.ForMember(dest => dest.PropertyTypes, map => map.MapFrom(source =>
-                    //    source.Properties.Select(Mapper.Map<PropertyType>)));
+                .MapPropertyGroupBasicToPropertyGroupPersistence<PropertyGroupBasic<PropertyTypeBasic>, PropertyTypeBasic>();
 
+            //for members
+            config.CreateMap<PropertyGroupBasic<MemberPropertyTypeBasic>, PropertyGroup>()
+                .MapPropertyGroupBasicToPropertyGroupPersistence<PropertyGroupBasic<MemberPropertyTypeBasic>, MemberPropertyTypeBasic>();
+
+            //for doc types, media types
             config.CreateMap<PropertyGroupBasic<PropertyTypeBasic>, PropertyGroupDisplay<PropertyTypeDisplay>>()
-                .ForMember(dest => dest.Id, expression => expression.Condition(source => source.Id > 0))
-                .ForMember(g => g.ContentTypeId, expression => expression.Ignore())
-                .ForMember(g => g.ParentTabContentTypes, expression => expression.Ignore())
-                .ForMember(g => g.ParentTabContentTypeNames, expression => expression.Ignore())
-                .ForMember(g => g.Properties, expression => expression.MapFrom(display => display.Properties.Select(Mapper.Map<PropertyTypeDisplay>)));
+                .MapPropertyGroupBasicToPropertyGroupDisplay<PropertyGroupBasic<PropertyTypeBasic>, PropertyTypeBasic, PropertyTypeDisplay>();
+
+            //for members
+            config.CreateMap<PropertyGroupBasic<MemberPropertyTypeBasic>, PropertyGroupDisplay<MemberPropertyTypeDisplay>>()
+                .MapPropertyGroupBasicToPropertyGroupDisplay<PropertyGroupBasic<MemberPropertyTypeBasic>, MemberPropertyTypeBasic, MemberPropertyTypeDisplay>();
 
             config.CreateMap<PropertyTypeBasic, PropertyTypeDisplay>()
                 .ForMember(g => g.Editor, expression => expression.Ignore())
diff --git a/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapperExtensions.cs b/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapperExtensions.cs
index b3c8baa96e..431357d5f2 100644
--- a/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapperExtensions.cs
+++ b/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapperExtensions.cs
@@ -20,6 +20,34 @@ namespace Umbraco.Web.Models.Mapping
     internal static class ContentTypeModelMapperExtensions
     {
 
+        public static IMappingExpression<TSource, PropertyGroup> MapPropertyGroupBasicToPropertyGroupPersistence<TSource, TPropertyTypeBasic>(
+            this IMappingExpression<TSource, PropertyGroup> mapping)
+            where TSource : PropertyGroupBasic<TPropertyTypeBasic> 
+            where TPropertyTypeBasic : PropertyTypeBasic
+        {
+            return mapping
+                .ForMember(dest => dest.Id, map => map.Condition(source => source.Id > 0))
+                .ForMember(dest => dest.Key, map => map.Ignore())
+                .ForMember(dest => dest.HasIdentity, map => map.Ignore())
+                .ForMember(dest => dest.CreateDate, map => map.Ignore())
+                .ForMember(dest => dest.UpdateDate, map => map.Ignore())
+                .ForMember(dest => dest.PropertyTypes, map => map.Ignore());
+        }
+
+        public static IMappingExpression<TSource, PropertyGroupDisplay<TPropertyTypeDisplay>> MapPropertyGroupBasicToPropertyGroupDisplay<TSource, TPropertyTypeBasic, TPropertyTypeDisplay>(
+            this IMappingExpression<TSource, PropertyGroupDisplay<TPropertyTypeDisplay>> mapping)
+            where TSource : PropertyGroupBasic<TPropertyTypeBasic>
+            where TPropertyTypeBasic : PropertyTypeBasic 
+            where TPropertyTypeDisplay : PropertyTypeDisplay
+        {
+            return mapping
+                .ForMember(dest => dest.Id, expression => expression.Condition(source => source.Id > 0))
+                .ForMember(g => g.ContentTypeId, expression => expression.Ignore())
+                .ForMember(g => g.ParentTabContentTypes, expression => expression.Ignore())
+                .ForMember(g => g.ParentTabContentTypeNames, expression => expression.Ignore())
+                .ForMember(g => g.Properties, expression => expression.MapFrom(display => display.Properties.Select(Mapper.Map<TPropertyTypeDisplay>)));
+        }
+
         public static void AfterMapContentTypeSaveToEntity<TSource, TDestination>(
             TSource source, TDestination dest,
             ApplicationContext applicationContext)
@@ -47,11 +75,12 @@ namespace Umbraco.Web.Models.Mapping
             }
         }
 
-        public static IMappingExpression<TSource, TDestination> MapBaseContentTypeSaveToDisplay<TSource, TDestination, TPropertyTypeDisplay>(
+        public static IMappingExpression<TSource, TDestination> MapBaseContentTypeSaveToDisplay<TSource, TPropertyTypeSource, TDestination, TPropertyTypeDestination>(
             this IMappingExpression<TSource, TDestination> mapping)
-            where TSource : ContentTypeSave
-            where TDestination : ContentTypeCompositionDisplay<TPropertyTypeDisplay> 
-            where TPropertyTypeDisplay : PropertyTypeDisplay
+            where TSource : ContentTypeSave<TPropertyTypeSource>
+            where TDestination : ContentTypeCompositionDisplay<TPropertyTypeDestination> 
+            where TPropertyTypeDestination : PropertyTypeDisplay 
+            where TPropertyTypeSource : PropertyTypeBasic
         {
             return mapping
                 .ForMember(dto => dto.CreateDate, expression => expression.Ignore())
@@ -60,7 +89,7 @@ namespace Umbraco.Web.Models.Mapping
                 .ForMember(dto => dto.Notifications, expression => expression.Ignore())
                 .ForMember(dto => dto.Errors, expression => expression.Ignore())
                 .ForMember(dto => dto.LockedCompositeContentTypes, exp => exp.Ignore())
-                .ForMember(dto => dto.Groups, expression => expression.ResolveUsing(new PropertyGroupDisplayResolver<TSource, TPropertyTypeDisplay>()));
+                .ForMember(dto => dto.Groups, expression => expression.ResolveUsing(new PropertyGroupDisplayResolver<TSource, TPropertyTypeSource, TPropertyTypeDestination>()));
         }
 
         public static IMappingExpression<TSource, TDestination> MapBaseContentTypeEntityToDisplay<TSource, TDestination, TPropertyTypeDisplay>(
diff --git a/src/Umbraco.Web/Models/Mapping/PropertyGroupDisplayResolver.cs b/src/Umbraco.Web/Models/Mapping/PropertyGroupDisplayResolver.cs
index 52f7bc643a..2f11eb04c4 100644
--- a/src/Umbraco.Web/Models/Mapping/PropertyGroupDisplayResolver.cs
+++ b/src/Umbraco.Web/Models/Mapping/PropertyGroupDisplayResolver.cs
@@ -5,13 +5,14 @@ using Umbraco.Web.Models.ContentEditing;
 
 namespace Umbraco.Web.Models.Mapping
 {
-    internal class PropertyGroupDisplayResolver<TSource, TPropertyTypeDisplay> : ValueResolver<IEnumerable<TSource>, IEnumerable<PropertyGroupDisplay<TPropertyTypeDisplay>>>
-        where TSource : ContentTypeSave 
-        where TPropertyTypeDisplay : PropertyTypeDisplay
+    internal class PropertyGroupDisplayResolver<TSource, TPropertyTypeSource, TPropertyTypeDestination> : ValueResolver<TSource, IEnumerable<PropertyGroupDisplay<TPropertyTypeDestination>>>
+        where TSource : ContentTypeSave<TPropertyTypeSource>
+        where TPropertyTypeDestination : PropertyTypeDisplay 
+        where TPropertyTypeSource : PropertyTypeBasic
     {
-        protected override IEnumerable<PropertyGroupDisplay<TPropertyTypeDisplay>> ResolveCore(IEnumerable<TSource> source)
+        protected override IEnumerable<PropertyGroupDisplay<TPropertyTypeDestination>> ResolveCore(TSource source)
         {
-            return source.Select(Mapper.Map<PropertyGroupDisplay<TPropertyTypeDisplay>>);
+            return source.Groups.Select(Mapper.Map<PropertyGroupDisplay<TPropertyTypeDestination>>);
         }
     }
 }
\ No newline at end of file