diff --git a/src/Nest/CommonAbstractions/ConnectionSettings/ClrPropertyMapping.cs b/src/Nest/CommonAbstractions/ConnectionSettings/ClrPropertyMapping.cs
new file mode 100644
index 00000000000..4db5de2a669
--- /dev/null
+++ b/src/Nest/CommonAbstractions/ConnectionSettings/ClrPropertyMapping.cs
@@ -0,0 +1,43 @@
+using System;
+using System.Linq.Expressions;
+
+namespace Nest
+{
+	public abstract class ClrPropertyMappingBase<TDocument> : IClrPropertyMapping<TDocument>
+		where TDocument : class
+	{
+		Expression<Func<TDocument, object>> IClrPropertyMapping<TDocument>.Property { get; set; }
+		bool IClrPropertyMapping<TDocument>.Ignore { get; set; }
+		string IClrPropertyMapping<TDocument>.NewName { get; set; }
+
+		protected IClrPropertyMapping<TDocument> Self => this;
+
+		protected ClrPropertyMappingBase(Expression<Func<TDocument, object>> property) => Self.Property = property;
+
+		IPropertyMapping IClrPropertyMapping<TDocument>.ToPropertyMapping() => Self.Ignore
+			? PropertyMapping.Ignored
+			: new PropertyMapping {Name = Self.NewName};
+	}
+
+	public interface IClrPropertyMapping<TDocument> where TDocument : class
+	{
+		Expression<Func<TDocument, object>> Property { get; set; }
+		bool Ignore { get; set; }
+		string NewName { get; set; }
+		IPropertyMapping ToPropertyMapping();
+	}
+
+	public class IgnoreClrPropertyMapping<TDocument> : ClrPropertyMappingBase<TDocument> where TDocument : class
+	{
+		public IgnoreClrPropertyMapping(Expression<Func<TDocument, object>> property) : base(property) => Self.Ignore = true;
+	}
+
+	public class RenameClrPropertyMapping<TDocument> : ClrPropertyMappingBase<TDocument> where TDocument : class
+	{
+		public RenameClrPropertyMapping(Expression<Func<TDocument, object>> property, string newName) : base(property)
+		{
+			newName.ThrowIfNull(nameof(newName));
+			Self.NewName = newName;
+		}
+	}
+}
diff --git a/src/Nest/CommonAbstractions/ConnectionSettings/ClrTypeMapping.cs b/src/Nest/CommonAbstractions/ConnectionSettings/ClrTypeMapping.cs
index 537d77fc502..f11ec67604d 100644
--- a/src/Nest/CommonAbstractions/ConnectionSettings/ClrTypeMapping.cs
+++ b/src/Nest/CommonAbstractions/ConnectionSettings/ClrTypeMapping.cs
@@ -1,155 +1,149 @@
 using System;
 using System.Collections.Generic;
 using System.Linq.Expressions;
-using Elasticsearch.Net;
 
 namespace Nest
 {
-	public interface IClrTypeMapping<T> where T : class
+	public interface IClrTypeMapping
 	{
-		Type Type { get; }
+		/// <summary>
+		/// The CLR type the mapping relates to
+		/// </summary>
+		Type ClrType { get; }
 
 		/// <summary>
-		/// When specified dictates the default Elasticsearch index name for <typeparamref name="T"/>
+		/// The default Elasticsearch index name for <see cref="ClrType"/>
 		/// </summary>
 		string IndexName { get; set; }
 
 		/// <summary>
-		/// When specified dictates the default Elasticsearch type name for <typeparamref name="T" />
+		/// The default Elasticsearch type name for <see cref="ClrType"/>
 		/// </summary>
 		string TypeName { get; set; }
 
 		/// <summary>
-		/// When specified dictates the relation name for <typeparamref name="T" /> to resolve to.
+		/// The relation name for <see cref="ClrType"/> to resolve to.
 		/// </summary>
 		string RelationName { get; set; }
+	}
 
+	public interface IClrTypeMapping<TDocument> : IClrTypeMapping where TDocument : class
+	{
 		/// <summary>
-		/// Allows you to set a default Id property on <typeparamref name="T" /> that NEST will evaluate
+		/// Set a default Id property on CLR type <typeparamref name="TDocument" /> that NEST will evaluate
 		/// </summary>
-		Expression<Func<T, object>> IdProperty { get; set; }
+		Expression<Func<TDocument, object>> IdProperty { get; set; }
 
 		/// <summary>
-		/// When specified allows you to ignore or rename certain properties of clr type <typeparamref name="T" />
+		/// Ignore or rename certain properties of CLR type <typeparamref name="TDocument" />
 		/// </summary>
-		IList<IClrTypePropertyMapping<T>> Properties { get; set; }
+		IList<IClrPropertyMapping<TDocument>> Properties { get; set; }
 	}
 
-	public class ClrTypeMapping<T> : IClrTypeMapping<T> where T : class
+	public class ClrTypeMapping : IClrTypeMapping
 	{
-		public Type Type { get; } = typeof (T);
-
 		/// <summary>
-		/// When specified dictates the default Elasticsearch index name for <typeparamref name="T"/>
+		/// Initializes a new instance of <see cref="ClrTypeMapping"/>
 		/// </summary>
+		public ClrTypeMapping(Type type) => ClrType = type;
+
+		/// <inheritdoc />
+		public Type ClrType { get; }
+
+		/// <inheritdoc />
 		public string IndexName { get; set; }
 
-		/// <summary>
-		/// When specified dictates the default Elasticsearch type name for <typeparamref name="T" />
-		/// </summary>
+		/// <inheritdoc />
 		public string TypeName { get; set; }
 
-		/// <summary>
-		/// When specified dictates the relation name for <typeparamref name="T" /> to resolve to.
-		/// </summary>
+		/// <inheritdoc />
 		public string RelationName { get; set; }
 
-		/// <summary>
-		/// Allows you to set a default Id property on <typeparamref name="T" /> that NEST will evaluate
-		/// </summary>
-		public Expression<Func<T, object>> IdProperty { get; set; }
+	}
+	public class ClrTypeMapping<TDocument> : ClrTypeMapping, IClrTypeMapping<TDocument> where TDocument : class
+	{
+		public ClrTypeMapping() : base(typeof(TDocument)) { }
+
+		/// <inheritdoc />
+		public Expression<Func<TDocument, object>> IdProperty { get; set; }
 
-		public IList<IClrTypePropertyMapping<T>> Properties { get; set; }
+		/// <inheritdoc />
+		public IList<IClrPropertyMapping<TDocument>> Properties { get; set; }
 	}
 
-	public class ClrTypeMappingDescriptor<T> : DescriptorBase<ClrTypeMappingDescriptor<T>,IClrTypeMapping<T>> , IClrTypeMapping<T>
-		where T : class
+	public class ClrTypeMappingDescriptor : DescriptorBase<ClrTypeMappingDescriptor,IClrTypeMapping> , IClrTypeMapping
 	{
-		Type IClrTypeMapping<T>.Type { get; } = typeof (T);
-		string IClrTypeMapping<T>.IndexName { get; set; }
-		string IClrTypeMapping<T>.TypeName { get; set; }
-		string IClrTypeMapping<T>.RelationName { get; set; }
-		Expression<Func<T, object>> IClrTypeMapping<T>.IdProperty { get; set; }
-		IList<IClrTypePropertyMapping<T>> IClrTypeMapping<T>.Properties { get; set; } = new List<IClrTypePropertyMapping<T>>();
+		private readonly Type _type;
 
 		/// <summary>
-		/// When specified dictates the default Elasticsearch index name for <typeparamref name="T"/>
+		/// Instantiates a new instance of <see cref="ClrTypeMappingDescriptor"/>
 		/// </summary>
-		public ClrTypeMappingDescriptor<T> IndexName(string indexName) => Assign(a => a.IndexName = indexName);
+		/// <param name="type">The CLR type to map</param>
+		public ClrTypeMappingDescriptor(Type type) => _type = type;
 
-		/// <summary>
-		/// When specified dictates the default Elasticsearch type name for <typeparamref name="T" />
-		/// </summary>
-		public ClrTypeMappingDescriptor<T> TypeName(string typeName) => Assign(a => a.TypeName = typeName);
+		Type IClrTypeMapping.ClrType => _type;
+		string IClrTypeMapping.IndexName { get; set; }
+		string IClrTypeMapping.TypeName { get; set; }
+		string IClrTypeMapping.RelationName { get; set; }
 
 		/// <summary>
-		/// When specified dictates the relation name for <typeparamref name="T" /> to resolve to.
+		/// The default Elasticsearch index name for the CLR type
 		/// </summary>
-		public ClrTypeMappingDescriptor<T> RelationName(string relationName) => Assign(a => a.RelationName = relationName);
+		public ClrTypeMappingDescriptor IndexName(string indexName) => Assign(a => a.IndexName = indexName);
 
 		/// <summary>
-		/// Allows you to set a default Id property on <typeparamref name="T" /> that NEST will evaluate
+		/// The default Elasticsearch type name for the CLR type
 		/// </summary>
-		public ClrTypeMappingDescriptor<T> IdProperty(Expression<Func<T, object>> property) => Assign(a => a.IdProperty = property);
+		public ClrTypeMappingDescriptor TypeName(string typeName) => Assign(a => a.TypeName = typeName);
 
 		/// <summary>
-		/// When specified allows you to ignore <param name="property"></param> on clr type <typeparamref name="T" />
+		/// The relation name for the CLR type to resolve to.
 		/// </summary>
-		public ClrTypeMappingDescriptor<T> Ignore(Expression<Func<T, object>> property) =>
-			Assign(a => a.Properties.Add(new IgnorePropertyMapping<T>(property)));
-
-		/// <summary>
-		/// When specified allows you to rename <param name="property"></param> on clr type <typeparamref name="T" />
-		/// </summary>
-		public ClrTypeMappingDescriptor<T> Rename(Expression<Func<T, object>> property, string newName) =>
-			Assign(a => a.Properties.Add(new RenamePropertyMapping<T>(property, newName)));
-
+		public ClrTypeMappingDescriptor RelationName(string relationName) => Assign(a => a.RelationName = relationName);
 	}
 
-	public interface IClrTypePropertyMapping<T> where T : class
+	public class ClrTypeMappingDescriptor<TDocument>
+		: DescriptorBase<ClrTypeMappingDescriptor<TDocument>,IClrTypeMapping<TDocument>>, IClrTypeMapping<TDocument>
+		where TDocument : class
 	{
-		Expression<Func<T, object>> Property { get; set; }
-		bool Ignore { get; set; }
-		string NewName { get; set; }
-		IPropertyMapping ToPropertyMapping();
-	}
-
-	public abstract class ClrPropertyMappingBase<T> : IClrTypePropertyMapping<T>
-		where T : class
-	{
-		protected IClrTypePropertyMapping<T> Self => this;
+		Type IClrTypeMapping.ClrType { get; } = typeof (TDocument);
+		string IClrTypeMapping.IndexName { get; set; }
+		string IClrTypeMapping.TypeName { get; set; }
+		string IClrTypeMapping.RelationName { get; set; }
+		Expression<Func<TDocument, object>> IClrTypeMapping<TDocument>.IdProperty { get; set; }
+		IList<IClrPropertyMapping<TDocument>> IClrTypeMapping<TDocument>.Properties { get; set; } = new List<IClrPropertyMapping<TDocument>>();
 
-		Expression<Func<T, object>> IClrTypePropertyMapping<T>.Property { get; set; }
+		/// <summary>
+		/// The default Elasticsearch index name for <typeparamref name="TDocument"/>
+		/// </summary>
+		public ClrTypeMappingDescriptor<TDocument> IndexName(string indexName) => Assign(a => a.IndexName = indexName);
 
-		bool IClrTypePropertyMapping<T>.Ignore { get; set; }
+		/// <summary>
+		/// The default Elasticsearch type name for <typeparamref name="TDocument" />
+		/// </summary>
+		public ClrTypeMappingDescriptor<TDocument> TypeName(string typeName) => Assign(a => a.TypeName = typeName);
 
-		string IClrTypePropertyMapping<T>.NewName { get; set; }
+		/// <summary>
+		/// The relation name for <typeparamref name="TDocument" /> to resolve to.
+		/// </summary>
+		public ClrTypeMappingDescriptor<TDocument> RelationName(string relationName) => Assign(a => a.RelationName = relationName);
 
-		protected ClrPropertyMappingBase(Expression<Func<T, object>> property)
-		{
-			Self.Property = property;
-		}
+		/// <summary>
+		/// Set a default Id property on CLR type <typeparamref name="TDocument" /> that NEST will evaluate
+		/// </summary>
+		public ClrTypeMappingDescriptor<TDocument> IdProperty(Expression<Func<TDocument, object>> property) => Assign(a => a.IdProperty = property);
 
-		IPropertyMapping IClrTypePropertyMapping<T>.ToPropertyMapping() => Self.Ignore ? PropertyMapping.Ignored : new PropertyMapping {Name = Self.NewName};
-	}
+		/// <summary>
+		/// Ignore <paramref name="property" /> on CLR type <typeparamref name="TDocument" />
+		/// </summary>
+		public ClrTypeMappingDescriptor<TDocument> Ignore(Expression<Func<TDocument, object>> property) =>
+			Assign(a => a.Properties.Add(new IgnoreClrPropertyMapping<TDocument>(property)));
 
-	public class IgnorePropertyMapping<T> : ClrPropertyMappingBase<T> where T : class
-	{
-		public IgnorePropertyMapping(Expression<Func<T, object>> property) : base(property)
-		{
-			Self.Ignore = true;
-		}
-	}
+		/// <summary>
+		/// Rename <paramref name="property" /> on CLR type <typeparamref name="TDocument" />
+		/// </summary>
+		public ClrTypeMappingDescriptor<TDocument> Rename(Expression<Func<TDocument, object>> property, string newName) =>
+			Assign(a => a.Properties.Add(new RenameClrPropertyMapping<TDocument>(property, newName)));
 
-	public class RenamePropertyMapping<T> : ClrPropertyMappingBase<T> where T : class
-	{
-		public RenamePropertyMapping(Expression<Func<T, object>> property, string newName) : base(property)
-		{
-			newName.ThrowIfNull(nameof(newName));
-			Self.NewName = newName;
-		}
 	}
-
-
-
 }
diff --git a/src/Nest/CommonAbstractions/ConnectionSettings/ConnectionSettingsBase.cs b/src/Nest/CommonAbstractions/ConnectionSettings/ConnectionSettingsBase.cs
index 3fb5d92d13b..edc225eb158 100644
--- a/src/Nest/CommonAbstractions/ConnectionSettings/ConnectionSettingsBase.cs
+++ b/src/Nest/CommonAbstractions/ConnectionSettings/ConnectionSettingsBase.cs
@@ -20,10 +20,12 @@ public ConnectionSettings(Uri uri = null)
 			: this(new SingleNodeConnectionPool(uri ?? new Uri("http://localhost:9200"))) { }
 
 		public ConnectionSettings(IConnectionPool connectionPool) : this(connectionPool, null, null) { }
+
 		public ConnectionSettings(IConnectionPool connectionPool, SourceSerializerFactory sourceSerializer)
 			: this(connectionPool, null, sourceSerializer) { }
 
 		public ConnectionSettings(IConnectionPool connectionPool, IConnection connection) : this(connectionPool, connection, null) { }
+
 		public ConnectionSettings(IConnectionPool connectionPool, IConnection connection, SourceSerializerFactory sourceSerializer)
 			: this(connectionPool, connection, sourceSerializer, null) { }
 
@@ -33,7 +35,6 @@ public ConnectionSettings(
 			SourceSerializerFactory sourceSerializer,
 			IPropertyMappingProvider propertyMappingProvider)
 			: base(connectionPool, connection, sourceSerializer, propertyMappingProvider) { }
-
 	}
 
 	/// <summary>
@@ -85,7 +86,7 @@ protected ConnectionSettingsBase(
 			IConnection connection,
 			ConnectionSettings.SourceSerializerFactory sourceSerializerFactory,
 			IPropertyMappingProvider propertyMappingProvider
-			)
+		)
 			: base(connectionPool, connection, null)
 		{
 			var defaultSerializer = new JsonNetSerializer(this);
@@ -113,7 +114,7 @@ IPropertyMappingProvider propertyMappingProvider
 		public TConnectionSettings PluralizeTypeNames()
 		{
 			this._defaultTypeNameInferrer = this.LowerCaseAndPluralizeTypeNameInferrer;
-			return (TConnectionSettings)this;
+			return (TConnectionSettings) this;
 		}
 
 		/// <summary>
@@ -125,7 +126,7 @@ public TConnectionSettings PluralizeTypeNames()
 		public TConnectionSettings DefaultIndex(string defaultIndex)
 		{
 			this._defaultIndex = defaultIndex;
-			return (TConnectionSettings)this;
+			return (TConnectionSettings) this;
 		}
 
 		private string LowerCaseAndPluralizeTypeNameInferrer(Type type)
@@ -143,7 +144,7 @@ private string LowerCaseAndPluralizeTypeNameInferrer(Type type)
 		public TConnectionSettings DefaultFieldNameInferrer(Func<string, string> fieldNameInferrer)
 		{
 			this._defaultFieldNameInferrer = fieldNameInferrer;
-			return (TConnectionSettings)this;
+			return (TConnectionSettings) this;
 		}
 
 		/// <summary>
@@ -155,17 +156,17 @@ public TConnectionSettings DefaultTypeNameInferrer(Func<Type, string> typeNameIn
 		{
 			typeNameInferrer.ThrowIfNull(nameof(typeNameInferrer));
 			this._defaultTypeNameInferrer = typeNameInferrer;
-			return (TConnectionSettings)this;
+			return (TConnectionSettings) this;
 		}
 
-        /// <summary>
-        /// Specify which property on a given POCO should be used to infer the id of the document when
-        /// indexed in Elasticsearch.
-        /// </summary>
-        /// <typeparam name="TDocument">The type of the document.</typeparam>
-        /// <param name="objectPath">The object path.</param>
-        /// <returns></returns>
-        private TConnectionSettings MapIdPropertyFor<TDocument>(Expression<Func<TDocument, object>> objectPath)
+		/// <summary>
+		/// Specify which property on a given POCO should be used to infer the id of the document when
+		/// indexed in Elasticsearch.
+		/// </summary>
+		/// <typeparam name="TDocument">The type of the document.</typeparam>
+		/// <param name="objectPath">The object path.</param>
+		/// <returns></returns>
+		private TConnectionSettings MapIdPropertyFor<TDocument>(Expression<Func<TDocument, object>> objectPath)
 		{
 			objectPath.ThrowIfNull(nameof(objectPath));
 
@@ -175,17 +176,18 @@ private TConnectionSettings MapIdPropertyFor<TDocument>(Expression<Func<TDocumen
 			if (this._idProperties.ContainsKey(typeof(TDocument)))
 			{
 				if (this._idProperties[typeof(TDocument)].Equals(fieldName))
-					return (TConnectionSettings)this;
+					return (TConnectionSettings) this;
 
-				throw new ArgumentException($"Cannot map '{fieldName}' as the id property for type '{typeof(TDocument).Name}': it already has '{this._idProperties[typeof(TDocument)]}' mapped.");
+				throw new ArgumentException(
+					$"Cannot map '{fieldName}' as the id property for type '{typeof(TDocument).Name}': it already has '{this._idProperties[typeof(TDocument)]}' mapped.");
 			}
 
 			this._idProperties.Add(typeof(TDocument), fieldName);
 
-			return (TConnectionSettings)this;
+			return (TConnectionSettings) this;
 		}
 
-		private void ApplyPropertyMappings<TDocument>(IList<IClrTypePropertyMapping<TDocument>> mappings)
+		private void ApplyPropertyMappings<TDocument>(IList<IClrPropertyMapping<TDocument>> mappings)
 			where TDocument : class
 		{
 			foreach (var mapping in mappings)
@@ -207,34 +209,35 @@ private void ApplyPropertyMappings<TDocument>(IList<IClrTypePropertyMapping<TDoc
 					if (mappedAs.IsNullOrEmpty() && newName.IsNullOrEmpty())
 						throw new ArgumentException($"Property mapping '{e}' on type is already ignored");
 					if (mappedAs.IsNullOrEmpty())
-						throw new ArgumentException($"Property mapping '{e}' on type {typeName} can not be mapped to '{newName}' it already has an ignore mapping");
+						throw new ArgumentException(
+							$"Property mapping '{e}' on type {typeName} can not be mapped to '{newName}' it already has an ignore mapping");
 					if (newName.IsNullOrEmpty())
 						throw new ArgumentException($"Property mapping '{e}' on type {typeName} can not be ignored it already has a mapping to '{mappedAs}'");
-					throw new ArgumentException($"Property mapping '{e}' on type {typeName} can not be mapped to '{newName}' already mapped as '{mappedAs}'");
+					throw new ArgumentException(
+						$"Property mapping '{e}' on type {typeName} can not be mapped to '{newName}' already mapped as '{mappedAs}'");
 				}
 				_propertyMappings[memberInfo] = mapping.ToPropertyMapping();
 			}
 		}
 
-        /// <summary>
-        /// Specify how the mapping is inferred for a given POCO type.
-        /// Can be used to infer the index, type, id property and properties for the POCO.
-        /// </summary>
-        /// <typeparam name="TDocument">The type of the document.</typeparam>
-        /// <param name="selector">The selector.</param>
-        /// <returns></returns>
-        public TConnectionSettings InferMappingFor<TDocument>(Func<ClrTypeMappingDescriptor<TDocument>, IClrTypeMapping<TDocument>> selector)
+		/// <summary>
+		/// Specify how the mapping is inferred for a given POCO type. Can be used to infer the index, type and relation names.
+		/// The generic version also allows you to set a default id property and control serialization behavior for properties for the POCO.
+		/// </summary>
+		/// <typeparam name="TDocument">The type of the document.</typeparam>
+		/// <param name="selector">The selector.</param>
+		public TConnectionSettings InferMappingFor<TDocument>(Func<ClrTypeMappingDescriptor<TDocument>, IClrTypeMapping<TDocument>> selector)
 			where TDocument : class
 		{
 			var inferMapping = selector(new ClrTypeMappingDescriptor<TDocument>());
 			if (!inferMapping.IndexName.IsNullOrEmpty())
-				this._defaultIndices.Add(inferMapping.Type, inferMapping.IndexName);
+				this._defaultIndices.Add(inferMapping.ClrType, inferMapping.IndexName);
 
 			if (!inferMapping.TypeName.IsNullOrEmpty())
-				this._defaultTypeNames.Add(inferMapping.Type, inferMapping.TypeName);
+				this._defaultTypeNames.Add(inferMapping.ClrType, inferMapping.TypeName);
 
 			if (!inferMapping.RelationName.IsNullOrEmpty())
-				this._defaultRelationNames.Add(inferMapping.Type, inferMapping.RelationName);
+				this._defaultRelationNames.Add(inferMapping.ClrType, inferMapping.RelationName);
 
 			if (inferMapping.IdProperty != null)
 				this.MapIdPropertyFor<TDocument>(inferMapping.IdProperty);
@@ -242,8 +245,50 @@ public TConnectionSettings InferMappingFor<TDocument>(Func<ClrTypeMappingDescrip
 			if (inferMapping.Properties != null)
 				this.ApplyPropertyMappings<TDocument>(inferMapping.Properties);
 
-			return (TConnectionSettings)this;
+			return (TConnectionSettings) this;
 		}
 
+		/// <summary>
+		/// Specify how the mapping is inferred for a given POCO type. Can be used to infer the index, type, and relation names.
+		/// </summary>
+		/// <param name="documentType">The type of the POCO you wish to configure</param>
+		/// <param name="selector">describe the POCO configuration</param>
+		public TConnectionSettings InferMappingFor(Type documentType, Func<ClrTypeMappingDescriptor, IClrTypeMapping> selector)
+		{
+			var inferMapping = selector(new ClrTypeMappingDescriptor(documentType));
+			if (!inferMapping.IndexName.IsNullOrEmpty())
+				this._defaultIndices.Add(inferMapping.ClrType, inferMapping.IndexName);
+
+			if (!inferMapping.TypeName.IsNullOrEmpty())
+				this._defaultTypeNames.Add(inferMapping.ClrType, inferMapping.TypeName);
+
+			if (!inferMapping.RelationName.IsNullOrEmpty())
+				this._defaultRelationNames.Add(inferMapping.ClrType, inferMapping.RelationName);
+
+			return (TConnectionSettings) this;
+		}
+
+		/// <summary>
+		/// Specify how the mapping is inferred for a given POCO type. Can be used to infer the index, type, and relation names.
+		/// </summary>
+		/// <param name="documentType">The type of the POCO you wish to configure</param>
+		/// <param name="selector">describe the POCO configuration</param>
+		public TConnectionSettings InferMappings(IEnumerable<ClrTypeMapping> typeMappings)
+		{
+			if (typeMappings == null) return (TConnectionSettings) this;
+			foreach (var inferMapping in typeMappings)
+			{
+				if (!inferMapping.IndexName.IsNullOrEmpty())
+					this._defaultIndices.Add(inferMapping.ClrType, inferMapping.IndexName);
+
+				if (!inferMapping.TypeName.IsNullOrEmpty())
+					this._defaultTypeNames.Add(inferMapping.ClrType, inferMapping.TypeName);
+
+				if (!inferMapping.RelationName.IsNullOrEmpty())
+					this._defaultRelationNames.Add(inferMapping.ClrType, inferMapping.RelationName);
+			}
+
+			return (TConnectionSettings) this;
+		}
 	}
 }
diff --git a/src/Nest/CommonAbstractions/SerializationBehavior/PropertyMapping.cs b/src/Nest/CommonAbstractions/SerializationBehavior/PropertyMapping.cs
index a2b2b772283..a6bbc5a01af 100644
--- a/src/Nest/CommonAbstractions/SerializationBehavior/PropertyMapping.cs
+++ b/src/Nest/CommonAbstractions/SerializationBehavior/PropertyMapping.cs
@@ -4,20 +4,20 @@
 
 namespace Nest
 {
-	/// <summary> This class allows a serializer to report back on a properties behavior </summary>
+	/// <summary>Determines how a POCO property maps to the property on a JSON object when serialized</summary>
 	public interface IPropertyMapping
 	{
-		/// <summary> Override the json property name of a type </summary>
+		/// <summary> Override the property name serialized to JSON for this property</summary>
 		string Name { get; set; }
 		/// <summary>
 		/// Ignore this property completely
-		/// <pre>- When mapping automatically using AutoMap()</pre>
-		/// <pre>- When Indexing this type do not serialize whatever this value hold</pre>
+		/// <para>- When mapping automatically using <see cref="TypeMappingDescriptor{T}.AutoMap{TDocument}"/></para>
+		/// <para>- When Indexing this type do not serialize this property and its value</para>
 		/// </summary>
 		bool Ignore { get; set; }
 	}
 
-	/// <summary> This class allows a serializer to report back on a properties behavior </summary>
+	/// <inheritdoc/>
 	public class PropertyMapping : IPropertyMapping
 	{
 		public static PropertyMapping Ignored = new PropertyMapping { Ignore = true };
@@ -29,15 +29,23 @@ public class PropertyMapping : IPropertyMapping
 		public bool Ignore { get; set; }
 	}
 
+	/// <summary>
+	/// Provides mappings for POCO properties
+	/// </summary>
 	public interface IPropertyMappingProvider
 	{
+		/// <summary>
+		/// Creates an <see cref="IPropertyMapping"/> for a <see cref="MemberInfo"/>
+		/// </summary>
 		IPropertyMapping CreatePropertyMapping(MemberInfo memberInfo);
 	}
 
+	/// <inheritdoc/>
 	public class PropertyMappingProvider : IPropertyMappingProvider
 	{
 		protected readonly ConcurrentDictionary<string, IPropertyMapping> Properties = new ConcurrentDictionary<string, IPropertyMapping>();
 
+		/// <inheritdoc/>
 		public virtual IPropertyMapping CreatePropertyMapping(MemberInfo memberInfo)
 		{
 			var memberInfoString = $"{memberInfo.DeclaringType?.FullName}.{memberInfo.Name}";
diff --git a/src/Nest/Mapping/PropertyMapping.cs b/src/Nest/Mapping/PropertyMapping.cs
index eda010ddd6a..c3d81e05d75 100644
--- a/src/Nest/Mapping/PropertyMapping.cs
+++ b/src/Nest/Mapping/PropertyMapping.cs
@@ -8,20 +8,20 @@ namespace Nest
 	public class PropertyMappingDescriptor<TDocument> : DescriptorBase<PropertyMappingDescriptor<TDocument>, IDescriptor>
 		where TDocument : class
 	{
-		internal IList<IClrTypePropertyMapping<TDocument>> Mappings { get; } = new List<IClrTypePropertyMapping<TDocument>>();
+		internal IList<IClrPropertyMapping<TDocument>> Mappings { get; } = new List<IClrPropertyMapping<TDocument>>();
 
 		public PropertyMappingDescriptor<TDocument> Rename(Expression<Func<TDocument, object>> property, string field)
 		{
 			property.ThrowIfNull(nameof(property));
 			field.ThrowIfNullOrEmpty(nameof(field));
-			this.Mappings.Add(new RenamePropertyMapping<TDocument>(property, field));
+			this.Mappings.Add(new RenameClrPropertyMapping<TDocument>(property, field));
 			return this;
 		}
 
 		public PropertyMappingDescriptor<TDocument> Ignore(Expression<Func<TDocument, object>> property)
 		{
 			property.ThrowIfNull(nameof(property));
-			this.Mappings.Add(new IgnorePropertyMapping<TDocument>(property));
+			this.Mappings.Add(new IgnoreClrPropertyMapping<TDocument>(property));
 			return this;
 		}
 	}