diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/ApiEndpoints/root.html b/src/CodeGeneration/CodeGeneration.LowLevelClient/ApiEndpoints/root.html
index d61f4df669e..ec55575285e 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/ApiEndpoints/root.html
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/ApiEndpoints/root.html
@@ -44,7 +44,7 @@
 
 
     <meta content="authenticity_token" name="csrf-param" />
-<meta content="dNEMMi9H8+4YtPers+GLRJfwlV8EMP3E4P0VutR2pFLWs+vOC4PqBd57IbDtyAFS5UHHWcZ/DiLFIz2b0k98BA==" name="csrf-token" />
+<meta content="nkRwL/MqKQCg+36QCMw24NATbnn6hdySAsxzrx/B3HEdUbaDmlKQZi+WExe2DZ4/OxZijRTAF388p7lxKeAjug==" name="csrf-token" />
 
     <link href="https://assets-cdn.github.com/assets/github-2a88a7bf0ff1b660d7ff29c3220a68751650b37fc53d40d3a7068e835fd213ec.css" media="all" rel="stylesheet" type="text/css" />
     <link href="https://assets-cdn.github.com/assets/github2-ee4170e0122d252766e3edc8c97b6cc6ae381c974013b5047ed5ad8895c56fe0.css" media="all" rel="stylesheet" type="text/css" />
@@ -141,7 +141,7 @@
   </a>
 
     <a class="social-count js-social-count" href="/elasticsearch/elasticsearch/stargazers">
-      9,173
+      9,176
     </a>
 
   </li>
@@ -3605,7 +3605,7 @@ <h3><span class="text-emphasized">Subversion</span> checkout URL</h3>
     </a>
 
     <ul class="site-footer-links">
-      <li>&copy; 2014 <span title="0.05490s from github-fe126-cp1-prd.iad.github.net">GitHub</span>, Inc.</li>
+      <li>&copy; 2014 <span title="0.06056s from github-fe129-cp1-prd.iad.github.net">GitHub</span>, Inc.</li>
         <li><a href="/site/terms">Terms</a></li>
         <li><a href="/site/privacy">Privacy</a></li>
         <li><a href="/security">Security</a></li>
diff --git a/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs b/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs
index 2d30073e593..f73b5532b29 100644
--- a/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs
+++ b/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs
@@ -3078,12 +3078,12 @@ public FlushRequestParameters ExpandWildcards(ExpandWildcards expand_wildcards)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/indices-get-index.html
 	///</pre>
 	///</summary>
-	public class IndicesGetRequestParameters : FluentRequestParameters<IndicesGetRequestParameters> 
+	public class GetIndexRequestParameters : FluentRequestParameters<GetIndexRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public IndicesGetRequestParameters Local(bool local)
+		public GetIndexRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.AddQueryString("local", this._local);
@@ -3093,7 +3093,7 @@ public IndicesGetRequestParameters Local(bool local)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Ignore unavailable indexes (default: false)</summary>
-		public IndicesGetRequestParameters IgnoreUnavailable(bool ignore_unavailable)
+		public GetIndexRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.AddQueryString("ignore_unavailable", this._ignore_unavailable);
@@ -3103,7 +3103,7 @@ public IndicesGetRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<summary>Ignore if a wildcard expression resolves to no concrete indices (default: false)</summary>
-		public IndicesGetRequestParameters AllowNoIndices(bool allow_no_indices)
+		public GetIndexRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.AddQueryString("allow_no_indices", this._allow_no_indices);
@@ -3113,7 +3113,7 @@ public IndicesGetRequestParameters AllowNoIndices(bool allow_no_indices)
 		
 		internal  string[] _expand_wildcards { get; set; }
 		///<summary>Whether wildcard expressions should get expanded to open or closed indices (default: open)</summary>
-		public IndicesGetRequestParameters ExpandWildcards(params string[] expand_wildcards)
+		public GetIndexRequestParameters ExpandWildcards(params string[] expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.AddQueryString("expand_wildcards", this._expand_wildcards);
diff --git a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
index 92230606af9..d689eaff9af 100644
--- a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
@@ -13752,7 +13752,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> IndicesGet<T>(string index, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<T> IndicesGet<T>(string index, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
@@ -13760,7 +13760,7 @@ public ElasticsearchResponse<T> IndicesGet<T>(string index, Func<IndicesGetReque
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new IndicesGetRequestParameters());
+				requestParams = requestParameters(new GetIndexRequestParameters());
 			}
 				
 
@@ -13786,7 +13786,7 @@ public ElasticsearchResponse<T> IndicesGet<T>(string index, Func<IndicesGetReque
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
@@ -13794,7 +13794,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, Func<Indi
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new IndicesGetRequestParameters());
+				requestParams = requestParameters(new GetIndexRequestParameters());
 			}
 				
 
@@ -13822,7 +13822,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, Func<Indi
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
@@ -13830,7 +13830,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, Func<In
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new IndicesGetRequestParameters());
+				requestParams = requestParameters(new GetIndexRequestParameters());
 			}
 				
 
@@ -13858,7 +13858,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, Func<In
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string index, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string index, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
@@ -13866,7 +13866,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string ind
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new IndicesGetRequestParameters());
+				requestParams = requestParameters(new GetIndexRequestParameters());
 			}
 				
 
@@ -13893,7 +13893,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> IndicesGet<T>(string index, string feature, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<T> IndicesGet<T>(string index, string feature, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			feature.ThrowIfNullOrEmpty("feature");
@@ -13902,7 +13902,7 @@ public ElasticsearchResponse<T> IndicesGet<T>(string index, string feature, Func
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new IndicesGetRequestParameters());
+				requestParams = requestParameters(new GetIndexRequestParameters());
 			}
 				
 
@@ -13929,7 +13929,7 @@ public ElasticsearchResponse<T> IndicesGet<T>(string index, string feature, Func
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, string feature, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, string feature, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			feature.ThrowIfNullOrEmpty("feature");
@@ -13938,7 +13938,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, string fe
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new IndicesGetRequestParameters());
+				requestParams = requestParameters(new GetIndexRequestParameters());
 			}
 				
 
@@ -13967,7 +13967,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, string fe
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, string feature, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, string feature, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			feature.ThrowIfNullOrEmpty("feature");
@@ -13976,7 +13976,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, string
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new IndicesGetRequestParameters());
+				requestParams = requestParameters(new GetIndexRequestParameters());
 			}
 				
 
@@ -14005,7 +14005,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string index, string feature, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string index, string feature, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			feature.ThrowIfNullOrEmpty("feature");
@@ -14014,7 +14014,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string ind
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new IndicesGetRequestParameters());
+				requestParams = requestParameters(new GetIndexRequestParameters());
 			}
 				
 
diff --git a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
index f2a1474c53c..7313d40c29f 100644
--- a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
@@ -7156,7 +7156,7 @@ public partial interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGet<T>(string index, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null);
+		ElasticsearchResponse<T> IndicesGet<T>(string index, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7174,7 +7174,7 @@ public partial interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7194,7 +7194,7 @@ public partial interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7214,7 +7214,7 @@ public partial interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string index, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string index, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{feature}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7233,7 +7233,7 @@ public partial interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGet<T>(string index, string feature, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null);
+		ElasticsearchResponse<T> IndicesGet<T>(string index, string feature, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{feature}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7252,7 +7252,7 @@ public partial interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, string feature, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAsync<T>(string index, string feature, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{feature}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7273,7 +7273,7 @@ public partial interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, string feature, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGet(string index, string feature, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{feature}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7294,7 +7294,7 @@ public partial interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string index, string feature, Func<IndicesGetRequestParameters, IndicesGetRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAsync(string index, string feature, Func<GetIndexRequestParameters, GetIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
diff --git a/src/Nest/ConvenienceExtensions/CreateIndexExtensions.cs b/src/Nest/ConvenienceExtensions/CreateIndexExtensions.cs
index 941f314bf8d..5a819a9cc3a 100644
--- a/src/Nest/ConvenienceExtensions/CreateIndexExtensions.cs
+++ b/src/Nest/ConvenienceExtensions/CreateIndexExtensions.cs
@@ -16,23 +16,23 @@ public static class CreateIndexExtensions
 		/// <param name="client"></param>
 		/// <param name="index">The name of the index to be created</param>
 		/// <param name="createIndexSelector">A descriptor that further describes the parameters for the create index operation</param>
-		public static IIndicesOperationResponse CreateIndex(this IElasticClient client, string index, 
-			Func<CreateIndexDescriptor, CreateIndexDescriptor> createIndexSelector = null )
+		public static IIndicesOperationResponse CreateIndex(this IElasticClient client, string index,
+			Func<CreateIndexDescriptor, CreateIndexDescriptor> createIndexSelector = null)
 		{
-            return CreateIndex(client, index, createIndexSelector, client.CreateIndex);
-        }
+			return CreateIndex(client, index, createIndexSelector, client.CreateIndex);
+		}
 
-        /// <summary>
-        /// The create index API allows to instantiate an index. Elasticsearch provides support for multiple indices, 
-        /// including executing operations across several indices.
-        /// <para> </para>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html
-        /// </summary>
-        /// <param name="client"></param>
-        /// <param name="index">The name of the index to be created</param>
-        /// <param name="createIndexSelector">A descriptor that further describes the parameters for the create index operation</param>
-        [Obsolete("Scheduled to be removed in 2.0, please use CreateIndex instead.")]
-		public static IIndicesOperationResponse CreatIndex(this IElasticClient client, string index, 
-			Func<CreateIndexDescriptor, CreateIndexDescriptor> createIndexSelector = null )
+		/// <summary>
+		/// The create index API allows to instantiate an index. Elasticsearch provides support for multiple indices, 
+		/// including executing operations across several indices.
+		/// <para> </para>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/indices-create-index.html
+		/// </summary>
+		/// <param name="client"></param>
+		/// <param name="index">The name of the index to be created</param>
+		/// <param name="createIndexSelector">A descriptor that further describes the parameters for the create index operation</param>
+		[Obsolete("Scheduled to be removed in 2.0, please use CreateIndex instead.")]
+		public static IIndicesOperationResponse CreatIndex(this IElasticClient client, string index,
+			Func<CreateIndexDescriptor, CreateIndexDescriptor> createIndexSelector = null)
 		{
 			return CreateIndex(client, index, createIndexSelector);
 		}
@@ -48,16 +48,16 @@ public static IIndicesOperationResponse CreatIndex(this IElasticClient client, s
 		public static Task<IIndicesOperationResponse> CreateIndexAsync(this IElasticClient client, string index,
 			Func<CreateIndexDescriptor, CreateIndexDescriptor> createIndexSelector = null)
 		{
-		    return CreateIndex(client, index, createIndexSelector, client.CreateIndexAsync);
+			return CreateIndex(client, index, createIndexSelector, client.CreateIndexAsync);
 		}
 
-	    private static TResponse CreateIndex<TResponse>(IElasticClient client, string index,
-	        Func<CreateIndexDescriptor, CreateIndexDescriptor> createIndexSelector,
-	        Func<Func<CreateIndexDescriptor, CreateIndexDescriptor>, TResponse> createIndexMethod)
-	    {
-            index.ThrowIfNullOrEmpty("index");
-            createIndexSelector = createIndexSelector ?? (c => c);
-            return createIndexMethod(c => createIndexSelector(c).Index(index));
-        }
-    }
+		private static TResponse CreateIndex<TResponse>(IElasticClient client, string index,
+			Func<CreateIndexDescriptor, CreateIndexDescriptor> createIndexSelector,
+			Func<Func<CreateIndexDescriptor, CreateIndexDescriptor>, TResponse> createIndexMethod)
+		{
+			index.ThrowIfNullOrEmpty("index");
+			createIndexSelector = createIndexSelector ?? (c => c);
+			return createIndexMethod(c => createIndexSelector(c).Index(index));
+		}
+	}
 }
diff --git a/src/Nest/DSL/GetIndexDescriptor.cs b/src/Nest/DSL/GetIndexDescriptor.cs
new file mode 100644
index 00000000000..e0acd7221ec
--- /dev/null
+++ b/src/Nest/DSL/GetIndexDescriptor.cs
@@ -0,0 +1,92 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public interface IGetIndexRequest : IIndicesOptionalExplicitAllPath<GetIndexRequestParameters>
+	{
+		/// <summary>
+		/// Be selective which features to return, i.e GetIndexFeature.Mappings | GetIndexFeature.Settings
+		/// </summary>
+		GetIndexFeature Features { get; set; }
+	}
+
+	internal static class GetIndexPathInfo
+	{
+		public static void Update(ElasticsearchPathInfo<GetIndexRequestParameters> pathInfo, IGetIndexRequest request)
+		{
+			if (pathInfo.Index.IsNullOrEmpty())
+				throw new DslException("Can not call GetIndex without specifying one or more indices or explicitly calling .AllIndices()");
+
+			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
+			if (request.Features == default(GetIndexFeature) || request.Features == GetIndexFeature.All)
+				return;
+
+			var features = new List<string>();
+			if ((request.Features & GetIndexFeature.Settings) == GetIndexFeature.Settings)
+				features.Add("_settings");
+			if ((request.Features & GetIndexFeature.Mappings) == GetIndexFeature.Mappings)
+				features.Add("_mappings");
+			if ((request.Features & GetIndexFeature.Warmers) == GetIndexFeature.Warmers)
+				features.Add("_warmers");
+			if ((request.Features & GetIndexFeature.Aliases) == GetIndexFeature.Aliases)
+				features.Add("_aliases");
+
+			pathInfo.Feature = string.Join(",", features);
+		}
+	}
+
+	public partial class GetIndexRequest : IndicesOptionalExplicitAllPathBase<GetIndexRequestParameters>, IGetIndexRequest
+	{
+		public GetIndexRequest() : base()
+		{
+			this.AllIndices = true;
+		}
+
+		public GetIndexRequest(IndexNameMarker index) : this()
+		{
+			this.Indices = new[] {index};
+		}
+
+		public GetIndexRequest(IEnumerable<IndexNameMarker> indices) : this()
+		{
+			this.Indices = indices;
+		}
+
+		/// <summary>
+		/// Be selective which features to return, i.e GetIndexFeature.Mappings | GetIndexFeature.Settings
+		/// </summary>
+		public GetIndexFeature Features { get; set; }
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<GetIndexRequestParameters> pathInfo)
+		{
+			GetIndexPathInfo.Update(pathInfo, this);
+		}
+	}
+
+	[DescriptorFor("IndicesGet")]
+	public partial class GetIndexDescriptor : IndicesOptionalExplicitAllPathDescriptor<GetIndexDescriptor, GetIndexRequestParameters>, IGetIndexRequest
+	{
+		private IGetIndexRequest Self { get { return this; } }
+		GetIndexFeature IGetIndexRequest.Features { get; set; }
+		
+		/// <summary>
+		/// Be selective which features to return, i.e GetIndexFeature.Mappings | GetIndexFeature.Settings
+		/// </summary>
+		public GetIndexDescriptor Features(GetIndexFeature features)
+		{
+			Self.Features = features;
+			return this;
+		}
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<GetIndexRequestParameters> pathInfo)
+		{
+			GetIndexPathInfo.Update(pathInfo, this);
+		}
+	}
+}
diff --git a/src/Nest/DSL/_Descriptors.generated.cs b/src/Nest/DSL/_Descriptors.generated.cs
index 0e54f5ac046..2519c2a48b8 100644
--- a/src/Nest/DSL/_Descriptors.generated.cs
+++ b/src/Nest/DSL/_Descriptors.generated.cs
@@ -2855,13 +2855,13 @@ public FlushDescriptor ExpandWildcards(ExpandWildcards expand_wildcards)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/indices-get-index.html
 	///</pre>
 	///</summary>
-	public partial class IndicesGetDescriptor  : BaseRequest<IndicesGetRequestParameters>
+	public partial class GetIndexDescriptor 
 	{
 		
 	
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public IndicesGetDescriptor Local(bool local = true)
+		public GetIndexDescriptor Local(bool local = true)
 		{
 			this.Request.RequestParameters.Local(local);
 			return this;
@@ -2869,7 +2869,7 @@ public IndicesGetDescriptor Local(bool local = true)
 		
 
 		///<summary>Ignore unavailable indexes (default: false)</summary>
-		public IndicesGetDescriptor IgnoreUnavailable(bool ignore_unavailable = true)
+		public GetIndexDescriptor IgnoreUnavailable(bool ignore_unavailable = true)
 		{
 			this.Request.RequestParameters.IgnoreUnavailable(ignore_unavailable);
 			return this;
@@ -2877,7 +2877,7 @@ public IndicesGetDescriptor IgnoreUnavailable(bool ignore_unavailable = true)
 		
 
 		///<summary>Ignore if a wildcard expression resolves to no concrete indices (default: false)</summary>
-		public IndicesGetDescriptor AllowNoIndices(bool allow_no_indices = true)
+		public GetIndexDescriptor AllowNoIndices(bool allow_no_indices = true)
 		{
 			this.Request.RequestParameters.AllowNoIndices(allow_no_indices);
 			return this;
@@ -2885,18 +2885,12 @@ public IndicesGetDescriptor AllowNoIndices(bool allow_no_indices = true)
 		
 
 		///<summary>Whether wildcard expressions should get expanded to open or closed indices (default: open)</summary>
-		public IndicesGetDescriptor ExpandWildcards(params string[] expand_wildcards)
+		public GetIndexDescriptor ExpandWildcards(params string[] expand_wildcards)
 		{
 			this.Request.RequestParameters.ExpandWildcards(expand_wildcards);
 			return this;
 		}
 		
-		
-		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<IndicesGetRequestParameters> pathInfo)
-		{
-			throw new NotImplementedException();
-		}
-		
 	
 	}
 	
diff --git a/src/Nest/DSL/_Requests.generated.cs b/src/Nest/DSL/_Requests.generated.cs
index 43827f39889..0c1a2c3224a 100644
--- a/src/Nest/DSL/_Requests.generated.cs
+++ b/src/Nest/DSL/_Requests.generated.cs
@@ -2588,7 +2588,7 @@ public ExpandWildcards ExpandWildcards
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.4/indices-get-index.html
 	///</pre>
 	///</summary>
-	public partial class IndicesGetRequest  : BasePathRequest<IndicesGetRequestParameters>
+	public partial class GetIndexRequest 
 			{
 		
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -2622,12 +2622,6 @@ public  string[] ExpandWildcards
 			set { this.Request.RequestParameters.AddQueryString("expand_wildcards", value); }
 		}
 		
-
-		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<IndicesGetRequestParameters> pathInfo)
-		{
-			throw new NotImplementedException();
-		}
-
 	}
 	
 		
diff --git a/src/Nest/Domain/Responses/GetIndexResponse.cs b/src/Nest/Domain/Responses/GetIndexResponse.cs
new file mode 100644
index 00000000000..36e8f56652a
--- /dev/null
+++ b/src/Nest/Domain/Responses/GetIndexResponse.cs
@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace Nest
+{
+	public interface IGetIndexResponse : IResponse
+	{
+		IDictionary<string, IndexSettings> Indices { get; set; }
+	}
+
+	[JsonObject]
+	public class GetIndexResponse : BaseResponse, IGetIndexResponse
+	{
+		public GetIndexResponse()
+		{
+			this.Indices = new Dictionary<string, IndexSettings>();
+		}
+		public IDictionary<string, IndexSettings> Indices { get; set; }
+	}
+
+	public class IndexMetadata
+	{
+		public IDictionary<string, object> Settings { get; set; }
+		
+		/// <summary>
+		/// Dynamic view of the settings object, useful for reading value from the settings
+		/// as it allows you to chain without nullrefs. Cannot be used to assign setting values though
+		/// </summary>
+		public dynamic AsExpando { get; internal set; }
+		
+		public AnalysisSettings Analysis { get; set; }
+
+		public IDictionary<string, RootObjectMapping> Mappings { get; set; }
+
+		[JsonConverter(typeof(DictionaryKeysAreNotPropertyNamesJsonConverter))]
+		public Dictionary<string, CreateAliasOperation> Aliases { get; set; }
+			
+		[JsonConverter(typeof(DictionaryKeysAreNotPropertyNamesJsonConverter))]
+		public Dictionary<string, WarmerMapping> Warmers { get; set; }
+
+		public SimilaritySettings Similarity { get; internal set; }
+	}
+}
diff --git a/src/Nest/Domain/Settings/IndexSettings.cs b/src/Nest/Domain/Settings/IndexSettings.cs
index f1860d6e4b6..0360cba9a8c 100644
--- a/src/Nest/Domain/Settings/IndexSettings.cs
+++ b/src/Nest/Domain/Settings/IndexSettings.cs
@@ -53,10 +53,11 @@ public int? NumberOfShards
 		
 		public AnalysisSettings Analysis { get; set; }
 
+		//TODO NEST 2.0 change this to dictionary to better reflect the actual elasticsearch structure
 		public IList<RootObjectMapping> Mappings { get; set; }
 
 		[JsonConverter(typeof(DictionaryKeysAreNotPropertyNamesJsonConverter))]
-		protected internal Dictionary<string, ICreateAliasOperation> Aliases { get; set; }
+		public Dictionary<string, ICreateAliasOperation> Aliases { get; set; }
 			
 		[JsonConverter(typeof(DictionaryKeysAreNotPropertyNamesJsonConverter))]
 		public Dictionary<string, WarmerMapping> Warmers { get; set; }
diff --git a/src/Nest/ElasticClient-GetIndex.cs b/src/Nest/ElasticClient-GetIndex.cs
new file mode 100644
index 00000000000..9fa4741bc4a
--- /dev/null
+++ b/src/Nest/ElasticClient-GetIndex.cs
@@ -0,0 +1,67 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Elasticsearch.Net;
+
+namespace Nest
+{
+	using GetIndexResponseConverter = Func<IElasticsearchResponse, Stream, GetIndexResponse>;
+
+	public partial class ElasticClient
+	{
+		/// <inheritdoc />
+		public IGetIndexResponse GetIndex(Func<GetIndexDescriptor, GetIndexDescriptor> getIndexSelector)
+		{
+			return this.Dispatch<GetIndexDescriptor, GetIndexRequestParameters, GetIndexResponse>(
+				getIndexSelector,
+				(p, d) => this.RawDispatch.IndicesGetDispatch<GetIndexResponse>(
+					p.DeserializationState(new GetIndexResponseConverter(this.DeserializeGetIndexResponse))
+				)
+			);
+		}
+
+		/// <inheritdoc />
+		public IGetIndexResponse GetIndex(IGetIndexRequest createIndexRequest)
+		{
+			return this.Dispatch<IGetIndexRequest, GetIndexRequestParameters, GetIndexResponse>(
+				createIndexRequest,
+				(p, d) => this.RawDispatch.IndicesGetDispatch<GetIndexResponse>(
+					p.DeserializationState(new GetIndexResponseConverter(this.DeserializeGetIndexResponse))
+				)
+			);
+		}
+
+		/// <inheritdoc />
+		public Task<IGetIndexResponse> GetIndexAsync(Func<GetIndexDescriptor, GetIndexDescriptor> getIndexSelector)
+		{
+			return this.DispatchAsync<GetIndexDescriptor, GetIndexRequestParameters, GetIndexResponse, IGetIndexResponse>(
+				getIndexSelector,
+				(p, d) => this.RawDispatch.IndicesGetDispatchAsync<GetIndexResponse>(
+					p.DeserializationState(new GetIndexResponseConverter(this.DeserializeGetIndexResponse))
+				)
+			);
+		}
+
+		/// <inheritdoc />
+		public Task<IGetIndexResponse> GetIndexAsync(IGetIndexRequest createIndexRequest)
+		{
+			return this.DispatchAsync<IGetIndexRequest, GetIndexRequestParameters, GetIndexResponse, IGetIndexResponse>(
+				createIndexRequest,
+				(p, d) => this.RawDispatch.IndicesGetDispatchAsync<GetIndexResponse>(
+					p.DeserializationState(new GetIndexResponseConverter(this.DeserializeGetIndexResponse))
+				)
+			);
+		}
+
+		private GetIndexResponse DeserializeGetIndexResponse(IElasticsearchResponse response, Stream stream)
+		{
+			return new GetIndexResponse
+			{
+				Indices = this.Serializer.Deserialize<Dictionary<string, IndexSettings>>(stream)
+			};
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/src/Nest/Enums/GetIndexFeature.cs b/src/Nest/Enums/GetIndexFeature.cs
new file mode 100644
index 00000000000..89d752ac649
--- /dev/null
+++ b/src/Nest/Enums/GetIndexFeature.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Runtime.Serialization;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+
+namespace Nest
+{
+	[Flags]
+	[JsonConverter(typeof(StringEnumConverter))]
+	public enum GetIndexFeature
+	{
+		All = Settings | Mappings | Warmers | Aliases,
+		[EnumMember(Value = "_settings")]
+		Settings = 1,
+		[EnumMember(Value = "_mappings")]
+		Mappings = 2,
+		[EnumMember(Value = "_warmers")]
+		Warmers = 4,
+		[EnumMember(Value = "_aliases")]
+		Aliases = 8
+	}
+}
\ No newline at end of file
diff --git a/src/Nest/Enums/RewriteMultiTerm.cs b/src/Nest/Enums/RewriteMultiTerm.cs
index d716529ea8b..bb9be39d184 100644
--- a/src/Nest/Enums/RewriteMultiTerm.cs
+++ b/src/Nest/Enums/RewriteMultiTerm.cs
@@ -7,6 +7,7 @@
 
 namespace Nest
 {
+	//TODO NEST 2.0 should this really be a flag enum?
 	[Flags]
 	[JsonConverter(typeof(StringEnumConverter))]
 	public enum RewriteMultiTerm
diff --git a/src/Nest/Extensions/Extensions.cs b/src/Nest/Extensions/Extensions.cs
index 2b1ff0504b2..ee337ba0fa9 100644
--- a/src/Nest/Extensions/Extensions.cs
+++ b/src/Nest/Extensions/Extensions.cs
@@ -24,7 +24,7 @@ internal static string GetStringValue(this Enum enumValue)
 				return string.Empty;
 		}
 
-		
+
 		public static T? ToEnum<T>(this string str) where T : struct
 		{
 			var enumType = typeof(T);
@@ -75,7 +75,7 @@ internal static void ThrowIfEmpty<T>(this IEnumerable<T> @object, string paramet
 				throw new ArgumentException("Argument can not be an empty collection", parameterName);
 		}
 
-        internal static IList<T> EagerConcat<T>(this IEnumerable<T> list, IEnumerable<T> other)
+		internal static IList<T> EagerConcat<T>(this IEnumerable<T> list, IEnumerable<T> other)
 		{
 			list = list.HasAny() ? list : Enumerable.Empty<T>();
 			var l = new List<T>(list);
@@ -100,7 +100,7 @@ internal static void ThrowIfNull<T>(this T value, string name)
 			if (value == null)
 				throw new ArgumentNullException(name);
 		}
-		
+
 		internal static string F(this string format, params object[] args)
 		{
 			var c = CultureInfo.InvariantCulture;
diff --git a/src/Nest/IElasticClient.cs b/src/Nest/IElasticClient.cs
index ac5e3d0ea2d..035bcacdc79 100644
--- a/src/Nest/IElasticClient.cs
+++ b/src/Nest/IElasticClient.cs
@@ -1581,6 +1581,18 @@ Task<ISearchShardsResponse> SearchShardsAsync<T>(Func<SearchShardsDescriptor<T>,
         /// <inheritdoc />
         Task<IDeleteScriptResponse> DeleteScriptAsync(Func<DeleteScriptDescriptor, DeleteScriptDescriptor> deleteScriptDescriptor);
 
+		/// <inheritdoc />
+		IGetIndexResponse GetIndex(Func<GetIndexDescriptor, GetIndexDescriptor> getIndexSelector);
+
+		/// <inheritdoc />
+		IGetIndexResponse GetIndex(IGetIndexRequest createIndexRequest);
+
+		/// <inheritdoc />
+		Task<IGetIndexResponse> GetIndexAsync(Func<GetIndexDescriptor, GetIndexDescriptor> getIndexSelector);
+
+		/// <inheritdoc />
+		Task<IGetIndexResponse> GetIndexAsync(IGetIndexRequest createIndexRequest);
+
 		/// <inheritdoc />
 		IExistsResponse SearchExists<T>(Func<SearchExistsDescriptor<T>, SearchExistsDescriptor<T>> selector)
 			where T : class;
diff --git a/src/Nest/Nest.csproj b/src/Nest/Nest.csproj
index 832cd778ff2..279b4ec7dc2 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -186,6 +186,7 @@
     <Compile Include="Domain\Responses\ClusterStatsResponse.cs" />
     <Compile Include="Domain\Responses\ClusterPendingTasksResponse.cs" />
     <Compile Include="Domain\Responses\DeleteAliasResponse.cs" />
+    <Compile Include="Domain\Responses\GetIndexResponse.cs" />
     <Compile Include="Domain\Responses\DeleteScriptResponse.cs" />
     <Compile Include="Domain\Responses\DeleteSearchTemplateResponse.cs" />
     <Compile Include="Domain\Responses\ExplainResponse.cs" />
@@ -228,8 +229,11 @@
     <Compile Include="DSL\Aggregations\GeoBoundsAggregationDescriptor.cs" />
     <Compile Include="DSL\Aggregations\ReverseNestedAggregationDescriptor.cs" />
     <Compile Include="DSL\VerifyRepositoryDescriptor.cs" />
+    <Compile Include="DSL\GetIndexDescriptor.cs" />
     <Compile Include="DSL\Filter\GeoHashCellFilterDescriptor.cs" />
     <Compile Include="DSL\DeleteScriptDescriptor.cs" />
+    <Compile Include="ElasticClient-GetIndex.cs" />
+    <Compile Include="Enums\GetIndexFeature.cs" />
     <Compile Include="DSL\GetScriptDescriptor.cs" />
     <Compile Include="DSL\SearchExistsDescriptor.cs" />
     <Compile Include="DSL\PutScriptDescriptor.cs" />
diff --git a/src/Nest/RawDispatch.generated.cs b/src/Nest/RawDispatch.generated.cs
index b2ae4d4a64f..d7313074f16 100644
--- a/src/Nest/RawDispatch.generated.cs
+++ b/src/Nest/RawDispatch.generated.cs
@@ -1748,7 +1748,7 @@ internal Task<ElasticsearchResponse<T>> IndicesFlushDispatchAsync<T>(Elasticsear
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetDispatch<T>(ElasticsearchPathInfo<IndicesGetRequestParameters> pathInfo )
+		internal ElasticsearchResponse<T> IndicesGetDispatch<T>(ElasticsearchPathInfo<GetIndexRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1766,7 +1766,7 @@ internal ElasticsearchResponse<T> IndicesGetDispatch<T>(ElasticsearchPathInfo<In
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetDispatchAsync<T>(ElasticsearchPathInfo<IndicesGetRequestParameters> pathInfo )
+		internal Task<ElasticsearchResponse<T>> IndicesGetDispatchAsync<T>(ElasticsearchPathInfo<GetIndexRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
diff --git a/src/Nest/Resolvers/Converters/IndexSettingsConverter.cs b/src/Nest/Resolvers/Converters/IndexSettingsConverter.cs
index ba7166bc20e..6d17f698463 100644
--- a/src/Nest/Resolvers/Converters/IndexSettingsConverter.cs
+++ b/src/Nest/Resolvers/Converters/IndexSettingsConverter.cs
@@ -30,13 +30,13 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 			writer.WriteStartObject();
 
 			WriteSettings(writer, serializer, indexSettings);
-			
+
 			WriteMappings(writer, serializer, indexSettings);
-			
+
 			WriteWarmers(writer, serializer, indexSettings);
-			
+
 			WriteAliases(writer, serializer, indexSettings);
-			
+
 			writer.WriteEndObject();
 		}
 
@@ -54,7 +54,7 @@ private static void WriteAliases(JsonWriter writer, JsonSerializer serializer, I
 			writer.WritePropertyName("aliases");
 			serializer.Serialize(writer, indexSettings.Aliases);
 		}
-		
+
 		private static void WriteWarmers(JsonWriter writer, JsonSerializer serializer, IndexSettings indexSettings)
 		{
 			if (indexSettings.Warmers.Count <= 0) return;
@@ -67,7 +67,7 @@ private static void WriteMappings(JsonWriter writer, JsonSerializer serializer,
 			if (indexSettings.Mappings.Count <= 0) return;
 			var contract = serializer.ContractResolver as SettingsContractResolver;
 			if (contract == null || contract.ConnectionSettings == null) return;
-			
+
 			writer.WritePropertyName("mappings");
 			serializer.Serialize(
 				writer,
@@ -123,32 +123,56 @@ private void WriteIndexSettings(JsonWriter writer, JsonSerializer serializer, In
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue,
 										JsonSerializer serializer)
 		{
-			JObject o = JObject.Load(reader);
 			var result = new IndexSettings();
-			var dictionary = new Dictionary<string, object>();
-			serializer.Populate(o.CreateReader(), dictionary);
-			result.Settings = dictionary;
-			result.AsExpando = DynamicDictionary.Create(dictionary);
-			foreach (var rootProperty in o.Children<JProperty>())
+			if (reader.TokenType != JsonToken.StartObject) return result;
+
+			var jsonObject = JObject.Load(reader);
+			if (jsonObject["settings"] != null && jsonObject["settings"]["index"] != null)
 			{
-				if (rootProperty.Name.Equals("analysis", StringComparison.InvariantCultureIgnoreCase))
+				var settings = jsonObject["settings"]["index"];
+				var dictionary = new Dictionary<string, object>();
+				serializer.Populate(settings.CreateReader(), dictionary);
+				result.Settings = dictionary;
+				result.AsExpando = DynamicDictionary.Create(dictionary);
+				
+				foreach (var rootProperty in settings.Children<JProperty>())
 				{
-					result.Analysis = serializer.Deserialize<AnalysisSettings>(rootProperty.Value.CreateReader());
-					result.Settings.Remove(rootProperty.Name);
-				}
-				else if (rootProperty.Name.Equals("warmers", StringComparison.InvariantCultureIgnoreCase))
-				{
-					foreach (var jWarmer in rootProperty.Value.Children<JProperty>())
+					if (rootProperty.Name.Equals("analysis", StringComparison.InvariantCultureIgnoreCase))
+					{
+						result.Analysis = serializer.Deserialize<AnalysisSettings>(rootProperty.Value.CreateReader());
+						result.Settings.Remove(rootProperty.Name);
+					}
+					else if (rootProperty.Name.Equals("similarity", StringComparison.InvariantCultureIgnoreCase))
 					{
-						result.Warmers[jWarmer.Name] = serializer.Deserialize<WarmerMapping>(jWarmer.Value.CreateReader());
+						result.Similarity = serializer.Deserialize<SimilaritySettings>(rootProperty.Value.CreateReader());
+						result.Settings.Remove(rootProperty.Name);
 					}
-					result.Settings.Remove(rootProperty.Name);
 				}
-				else if (rootProperty.Name.Equals("similarity", StringComparison.InvariantCultureIgnoreCase))
+			}
+			if (jsonObject["aliases"] != null)
+			{
+				var a = serializer.Deserialize<Dictionary<string, CreateAliasOperation>>(jsonObject["aliases"].CreateReader());
+				result.Aliases = a.ToDictionary(kv => kv.Key, kv => kv.Value as ICreateAliasOperation);
+			}
+			if (jsonObject["mappings"] != null)
+			{
+				var mappings = serializer.Deserialize<Dictionary<string, RootObjectMapping>>(jsonObject["mappings"].CreateReader());
+				result.Mappings = mappings.Select(kv =>
 				{
-					result.Similarity = serializer.Deserialize<SimilaritySettings>(rootProperty.Value.CreateReader());
-					result.Settings.Remove(rootProperty.Name);
-				}
+					var name = kv.Key;
+					kv.Value.Name = name;
+					return kv.Value;
+				}).ToList();
+			}
+			
+			if (jsonObject["warmers"] != null)
+			{
+				var warmers = serializer.Deserialize<Dictionary<string, WarmerMapping>>(jsonObject["warmers"].CreateReader());
+				result.Warmers = warmers.ToDictionary(kv=>kv.Key, kv =>
+				{
+					kv.Value.Name = kv.Key;
+					return kv.Value;
+				});
 			}
 			return result;
 		}
diff --git a/src/Nest/Resolvers/Converters/IndexSettingsResponseConverter.cs b/src/Nest/Resolvers/Converters/IndexSettingsResponseConverter.cs
index 094e847901a..7570654b02b 100644
--- a/src/Nest/Resolvers/Converters/IndexSettingsResponseConverter.cs
+++ b/src/Nest/Resolvers/Converters/IndexSettingsResponseConverter.cs
@@ -19,12 +19,10 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 		}
 		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
 		{
-			var dict = new Dictionary<string, Dictionary<string, Dictionary<string, IndexSettings>>>();
+			var dict = new Dictionary<string, IndexSettings>();
 			serializer.Populate(reader, dict);
 			var response = new IndexSettingsResponse();
-			if (!dict.HasAny() || !dict.First().Value.HasAny() || !dict.First().Value.First().Value.HasAny())
-				return response;
-			response.Nodes = dict.ToDictionary(k => k.Key, v => v.Value.First().Value.First().Value);
+			response.Nodes = dict;
 			return response;
 		}
 
diff --git a/src/Nest/Resolvers/Converters/WarmerMappingConverter.cs b/src/Nest/Resolvers/Converters/WarmerMappingConverter.cs
index d31ecbd9592..f619fa1bbbb 100644
--- a/src/Nest/Resolvers/Converters/WarmerMappingConverter.cs
+++ b/src/Nest/Resolvers/Converters/WarmerMappingConverter.cs
@@ -28,11 +28,13 @@ public override object ReadJson(JsonReader reader, Type objectType, object exist
 			var jObject = JObject.Load(reader);
 			var types = ((JArray)jObject.Property("types").Value).Values<string>().ToArray()
 				.Select(s=>(TypeNameMarker)s);
-			var source = jObject.Property("source").Value.ToString();
+
+			var source = serializer.Deserialize<SearchRequest>(jObject["source"].CreateReader());
 
 			return new WarmerMapping
 			{
 				Types = types, 
+				Source = source
 			};
 		}
 
diff --git a/src/Tests/Nest.Tests.Integration/Cluster/NodeTests.cs b/src/Tests/Nest.Tests.Integration/Cluster/NodeTests.cs
index cbbe007581d..23800b27188 100644
--- a/src/Tests/Nest.Tests.Integration/Cluster/NodeTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Cluster/NodeTests.cs
@@ -66,7 +66,7 @@ public void NodesHotThreads()
 			r.HotThreads.Count.Should().BeGreaterOrEqualTo(1);
 			var hotThreadInfo = r.HotThreads.First();
 			hotThreadInfo.Node.Should().NotBeNullOrEmpty();
-			hotThreadInfo.Threads.Count.ShouldBeEquivalentTo(5);
+			hotThreadInfo.Threads.Count.Should().BeGreaterThan(1);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/Tests/Nest.Tests.Integration/Core/Percolate/PercolateTests.cs b/src/Tests/Nest.Tests.Integration/Core/Percolate/PercolateTests.cs
index 0b8d2247613..75016a7d54a 100644
--- a/src/Tests/Nest.Tests.Integration/Core/Percolate/PercolateTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Core/Percolate/PercolateTests.cs
@@ -1,6 +1,7 @@
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
+using System.Runtime.InteropServices;
 using FluentAssertions;
 using Nest.Resolvers;
 using NUnit.Framework;
@@ -49,7 +50,6 @@ public void Percolate_ReturnsExpectedResults()
 			this.Client.IndexMany(projects, indexName);
 
 			this.Client.Refresh(r => r.Index(indexName));
-			
 
 			//Now we kick of multiple percolations
 				//provding document in the percolate request 
diff --git a/src/Tests/Nest.Tests.Integration/Indices/GetIndexTests.cs b/src/Tests/Nest.Tests.Integration/Indices/GetIndexTests.cs
new file mode 100644
index 00000000000..4da0439c6f3
--- /dev/null
+++ b/src/Tests/Nest.Tests.Integration/Indices/GetIndexTests.cs
@@ -0,0 +1,129 @@
+using System.Collections.Generic;
+using System.Linq;
+using FluentAssertions;
+using Nest.Tests.MockData.Domain;
+using NUnit.Framework;
+
+namespace Nest.Tests.Integration.Indices
+{
+	[TestFixture]
+	public class GetIndexTests : IntegrationTests
+	{
+		[Test]
+		[SkipVersion("0 - 1.3.9", "Get Index API is a 1.4 feature")]
+		public void GetSingleIndex()
+		{
+			var indexName = ElasticsearchConfiguration.NewUniqueIndexName();
+			var aliasName = ElasticsearchConfiguration.NewUniqueIndexName();
+			var warmerName = "get_comfy";
+			var create = this.Client.CreateIndex(s => s
+				.Index(indexName)
+				.AddAlias(aliasName, a=>a
+					.IndexRouting("routing")
+					.SearchRouting("routing")
+					.Filter<object>(f=>f.Term("country", "value"))
+				)
+				.AddMapping<ElasticsearchProject>(map=>map
+					.MapFromAttributes()
+				)
+				.Similarity(sim=>sim
+					.CustomSimilarities(cs => cs
+						.Add("my_bm25_similarity", new BM25Similarity
+						{
+							K1 = 2.0,
+							B = 0.75,
+							Normalization = "h1",
+							NormalizationH1C = "1.0",
+							DiscountOverlaps = true
+						})
+					)
+				)
+				.Analysis(a=>a
+					.Tokenizers(p=>p
+						.Add("myTokenizer", new KeywordTokenizer())
+					)
+					.TokenFilters(tf=>tf
+						.Add("myTokenFilter1", new AsciiFoldingTokenFilter())
+						.Add("myTokenFilter2", new UniqueTokenFilter())
+					)
+					.CharFilters(cf=>cf
+						.Add("my_html", new HtmlStripCharFilter())
+					)
+					.Analyzers(aa => aa.Add("myCustom", new CustomAnalyzer
+					{
+						Tokenizer = "myTokenizer",
+						Filter = new string[] { "myTokenFilter1", "myTokenFilter2" },
+						CharFilter = new string[] { "my_html" },
+						Alias = new string[] { "alias1", "alias2" }
+					}))
+				)
+				.AddWarmer(cw=>cw
+					.WarmerName(warmerName)
+					.Type<ElasticsearchProject>()
+					.Search(search=>search.Query(q=>q.Term("field", "value")))
+				)
+				.Settings(settings=>settings
+					.Add("somesetting", 1)
+				)
+			);
+			create.IsValid.Should().BeTrue();
+
+			var r = this.Client.GetIndex(f=>f.Index(indexName));
+			r.IsValid.Should().BeTrue();
+
+			r.Indices.Should().NotBeEmpty().And.ContainKey(indexName);
+
+			var index = r.Indices[indexName];
+			index.Aliases.Should().NotBeEmpty().And.ContainKey(aliasName);
+			index.Warmers.Should().NotBeEmpty().And.ContainKey(warmerName);
+			index.Mappings.Should().NotBeEmpty().And.ContainSingle(p=>p.Name.EqualsString("elasticsearchprojects"));
+			index.Settings.Should().NotBeEmpty().And.ContainKey("somesetting");
+			index.Analysis.Should().NotBeNull();
+			index.Similarity.Should().NotBeNull();
+
+			var alias = index.Aliases[aliasName];
+			alias.IndexRouting.Should().Be("routing");
+			alias.SearchRouting.Should().Be("routing");
+			IFilterContainer filter = alias.Filter;
+			filter.Should().NotBeNull();
+			filter.Term.Should().NotBeNull();
+			filter.Term.Field.Should().Be("country");
+			filter.Term.Value.Should().Be("value");
+
+			var warmer = index.Warmers[warmerName];
+			warmer.Should().NotBeNull();
+			warmer.Types.ShouldBeEquivalentTo(new TypeNameMarker[] { "elasticsearchprojects" });
+			warmer.Source.Should().NotBeNull();
+			warmer.Source.Query.Should().NotBeNull();
+			warmer.Source.Query.Term.Should().NotBeNull();
+			warmer.Source.Query.Term.Field.Should().Be("field");
+			warmer.Source.Query.Term.Value.Should().Be("value");
+			warmer.Name.Should().Be(warmerName);
+
+			var mapping = index.Mappings.FirstOrDefault(m=>m.Name.EqualsString("elasticsearchprojects"));
+			mapping.Properties.Should().NotBeEmpty();
+
+			var someSetting = index.Settings["somesetting"];
+			someSetting.Should().NotBeNull();
+			someSetting.Should().Be("1");
+
+			string uuid = index.AsExpando.uuid;
+			string created = index.AsExpando.version.created;
+			uuid.Should().NotBeNullOrWhiteSpace();
+			created.Should().NotBeNullOrWhiteSpace();
+
+			index.Analysis.Analyzers.Should().NotBeEmpty().And.ContainKey("myCustom");
+			var analyzer = index.Analysis.Analyzers["myCustom"] as CustomAnalyzer;
+			analyzer.Should().NotBeNull();
+			analyzer.Tokenizer.Should().Be("myTokenizer");
+
+			index.Similarity.CustomSimilarities.Should().NotBeEmpty().And.ContainKey("my_bm25_similarity");
+			var similarity = index.Similarity.CustomSimilarities["my_bm25_similarity"] as BM25Similarity;
+			similarity.Should().NotBeNull();
+
+
+
+		}
+		
+	}
+}
\ No newline at end of file
diff --git a/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs b/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs
index 7e415064044..4eee44b89d2 100644
--- a/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs
@@ -11,7 +11,7 @@ namespace Nest.Tests.Integration.Indices
 	///  Tests that test whether the query response can be successfully mapped or not
 	/// </summary>
 	[TestFixture]
-	public class IndicesTest : IntegrationTests 
+	public class IndicesTest : IntegrationTests
 	{
 		protected void TestDefaultAssertions(SearchResponse<ElasticsearchProject> queryResponse)
 		{
@@ -30,7 +30,7 @@ protected void TestDefaultAssertions(SearchResponse<ElasticsearchProject> queryR
 		[Test]
 		public void GetIndexSettingsSimple()
 		{
-			var r = this.Client.GetIndexSettings(i=>i.Index<ElasticsearchProject>());
+			var r = this.Client.GetIndexSettings(i => i.Index<ElasticsearchProject>());
 			Assert.True(r.IsValid);
 			Assert.NotNull(r.IndexSettings);
 			Assert.GreaterOrEqual(r.IndexSettings.NumberOfReplicas, 0);
@@ -39,20 +39,19 @@ public void GetIndexSettingsSimple()
 
 		[Test]
 		public void GetIndexSettingsComplex()
-
 		{
 			var index = Guid.NewGuid().ToString();
 			var settings = new IndexSettings();
 			settings.NumberOfReplicas = 4;
 			settings.NumberOfShards = 8;
-	
+
 			settings.Analysis.Analyzers.Add("snowball", new SnowballAnalyzer { Language = "English" });
-			settings.Analysis.Analyzers.Add("standard", new StandardAnalyzer { StopWords = new[]{"word1", "word2"}});
+			settings.Analysis.Analyzers.Add("standard", new StandardAnalyzer { StopWords = new[] { "word1", "word2" } });
 			settings.Analysis.Analyzers.Add("swedishlanguage", new LanguageAnalyzer(Language.Swedish) { StopWords = new[] { "word1", "word2" }, StemExclusionList = new[] { "stem1", "stem2" } });
 
 			settings.Analysis.CharFilters.Add("char1", new HtmlStripCharFilter());
-			settings.Analysis.CharFilters.Add("char2", new MappingCharFilter{ Mappings = new []{"ph=>f", "qu=>q"}});
-            settings.Analysis.CharFilters.Add("char3", new PatternReplaceCharFilter { Pattern = "sample(.*)", Replacement = "replacedSample $1" });
+			settings.Analysis.CharFilters.Add("char2", new MappingCharFilter { Mappings = new[] { "ph=>f", "qu=>q" } });
+			settings.Analysis.CharFilters.Add("char3", new PatternReplaceCharFilter { Pattern = "sample(.*)", Replacement = "replacedSample $1" });
 			settings.Analysis.TokenFilters.Add("tokenfilter1", new EdgeNGramTokenFilter());
 			settings.Analysis.TokenFilters.Add("tokenfilter2", new SnowballTokenFilter());
 
@@ -73,16 +72,16 @@ public void GetIndexSettingsComplex()
 					Normalization = "h1"
 				});
 
-			var typeMappingResult = this.Client.GetMapping<ElasticsearchProject>(gm=>gm.Index(ElasticsearchConfiguration.DefaultIndex).Type("elasticsearchprojects"));
+			var typeMappingResult = this.Client.GetMapping<ElasticsearchProject>(gm => gm.Index(ElasticsearchConfiguration.DefaultIndex).Type("elasticsearchprojects"));
 			var typeMapping = typeMappingResult.Mapping;
 			typeMapping.Name = index;
 			settings.Mappings.Add(typeMapping);
 
 			settings.Settings.Add("merge.policy.merge_factor", "10");
 
-			var createResponse = this.Client.CreateIndex(index, i=>i.InitializeUsing(settings));
+			var createResponse = this.Client.CreateIndex(index, i => i.InitializeUsing(settings));
 
-			var r = this.Client.GetIndexSettings(i=>i.Index(index));
+			var r = this.Client.GetIndexSettings(i => i.Index(index));
 			Assert.True(r.IsValid);
 			Assert.NotNull(r.IndexSettings.Settings.Count);
 			Assert.AreEqual(r.IndexSettings.NumberOfReplicas, 4);
@@ -90,7 +89,7 @@ public void GetIndexSettingsComplex()
 			//Assert.Greater(r.Setttings, 0);
 			Assert.NotNull(r.IndexSettings.AsExpando.merge.policy.merge_factor);
 			Assert.AreEqual(10, r.IndexSettings.AsExpando.merge.policy.merge_factor);
-			
+
 			Assert.AreEqual(3, r.IndexSettings.Analysis.Analyzers.Count);
 			{ // assert analyzers
 				Assert.True(r.IndexSettings.Analysis.Analyzers.ContainsKey("snowball"));
@@ -130,10 +129,10 @@ public void GetIndexSettingsComplex()
 				Assert.AreEqual(2, filter2.Mappings.Count());
 				Assert.True(filter2.Mappings.Contains("ph=>f"));
 				Assert.True(filter2.Mappings.Contains("qu=>q"));
-                var filter3 = r.IndexSettings.Analysis.CharFilters["char3"] as PatternReplaceCharFilter;
-                Assert.NotNull(filter3);
-                Assert.AreEqual("sample(.*)", filter3.Pattern);
-                Assert.AreEqual("replacedSample $1", filter3.Replacement);
+				var filter3 = r.IndexSettings.Analysis.CharFilters["char3"] as PatternReplaceCharFilter;
+				Assert.NotNull(filter3);
+				Assert.AreEqual("sample(.*)", filter3.Pattern);
+				Assert.AreEqual("replacedSample $1", filter3.Replacement);
 			}
 
 			Assert.AreEqual(2, r.IndexSettings.Analysis.TokenFilters.Count);
@@ -175,7 +174,7 @@ public void GetIndexSettingsComplex()
 				Assert.AreEqual("ttf", similarity2.Lambda);
 				Assert.AreEqual("h1", similarity2.Normalization);
 			}
-			this.Client.DeleteIndex(i=>i.Index(index));
+			this.Client.DeleteIndex(i => i.Index(index));
 		}
 		[Test]
 		public void UpdateSettingsSimple()
@@ -187,21 +186,21 @@ public void UpdateSettingsSimple()
 			settings.NumberOfShards = 5;
 			settings.Settings.Add("refresh_interval", "1s");
 			settings.Settings.Add("search.slowlog.threshold.fetch.warn", "1s");
-			client.CreateIndex(index, i=>i.InitializeUsing(settings));
+			client.CreateIndex(index, i => i.InitializeUsing(settings));
 
 			settings.Settings["refresh_interval"] = "-1";
 
-			var r = this.Client.UpdateSettings(us=>us
+			var r = this.Client.UpdateSettings(us => us
 				.Index(index)
 				.RefreshInterval("-1")
 			);
 
 			Assert.True(r.IsValid);
 			Assert.True(r.Acknowledged);
-			var getResponse = this.Client.GetIndexSettings(i=>i.Index(index));
+			var getResponse = this.Client.GetIndexSettings(i => i.Index(index));
 			Assert.AreEqual(getResponse.IndexSettings.Settings["refresh_interval"], "-1");
 
-			this.Client.DeleteIndex(i=>i.Index(index));
+			this.Client.DeleteIndex(i => i.Index(index));
 		}
 
 
@@ -210,7 +209,7 @@ public void UpdateSettingsSimple()
 		[Test]
 		public void CreateIndex()
 		{
-			var typeMappingResult = this.Client.GetMapping<ElasticsearchProject>(gm=>gm.Index(ElasticsearchConfiguration.DefaultIndex).Type("elasticsearchprojects"));
+			var typeMappingResult = this.Client.GetMapping<ElasticsearchProject>(gm => gm.Index(ElasticsearchConfiguration.DefaultIndex).Type("elasticsearchprojects"));
 			var typeMapping = typeMappingResult.Mapping;
 			typeMapping.Name = "mytype";
 			var settings = new IndexSettings();
@@ -220,14 +219,14 @@ public void CreateIndex()
 			settings.Analysis.Analyzers.Add("snowball", new SnowballAnalyzer { Language = "English" });
 
 			var indexName = Guid.NewGuid().ToString();
-			var response = this.Client.CreateIndex(indexName, i=>i.InitializeUsing(settings));
+			var response = this.Client.CreateIndex(indexName, i => i.InitializeUsing(settings));
 
 			Assert.IsTrue(response.IsValid);
 			Assert.IsTrue(response.Acknowledged);
 
-			var mappingResult = this.Client.GetMapping<ElasticsearchProject>(gm=>gm.Index(indexName).Type("mytype"));
+			var mappingResult = this.Client.GetMapping<ElasticsearchProject>(gm => gm.Index(indexName).Type("mytype"));
 			mappingResult.Mapping.Should().NotBeNull();
-			var deleteResponse = this.Client.DeleteIndex(i=>i.Index(indexName));
+			var deleteResponse = this.Client.DeleteIndex(i => i.Index(indexName));
 
 			Assert.IsTrue(deleteResponse.IsValid);
 			Assert.IsTrue(deleteResponse.Acknowledged);
@@ -241,14 +240,14 @@ public void CreateAndDeleteIndex()
 
 			var create = this.Client.CreateIndex(index);
 			create.IsValid.Should().BeTrue();
-			
+
 			var exists = this.Client.IndexExists(index);
 			exists.IsValid.Should().BeTrue();
 			exists.Exists.Should().BeTrue();
-			
+
 			var delete = this.Client.DeleteIndex(index);
 			delete.IsValid.Should().BeTrue();
-			
+
 			exists = this.Client.IndexExists(index);
 			exists.IsValid.Should().BeTrue();
 			exists.Exists.Should().BeFalse();
@@ -258,8 +257,8 @@ public void CreateAndDeleteIndex()
 		public void CreateIndexUsingDescriptor()
 		{
 			var index = ElasticsearchConfiguration.DefaultIndex + "_clone";
-			if (this.Client.IndexExists(i=>i.Index(index)).Exists)
-				this.Client.DeleteIndex(d=>d.Index(index));
+			if (this.Client.IndexExists(i => i.Index(index)).Exists)
+				this.Client.DeleteIndex(d => d.Index(index));
 
 			var result = this.Client.CreateIndex(index, c => c
 				.NumberOfReplicas(1)
@@ -281,18 +280,18 @@ public void CreateIndexUsingDescriptor()
 					.MapFromAttributes()
 					.Type("override")
 				)
-				.Analysis(a=>a
-					.Analyzers(an=>an
+				.Analysis(a => a
+					.Analyzers(an => an
 						.Add("standard", new StandardAnalyzer()
 						{
-							StopWords = new [] { "stop1", "stop2" }
+							StopWords = new[] { "stop1", "stop2" }
 						})
 					)
-					.Tokenizers(t=>t
+					.Tokenizers(t => t
 						.Add("myTokenizer", new StandardTokenizer { MaximumTokenLength = 900 })
 					)
 					.TokenFilters(t => t
-						.Add("myTokenFilter1", new StopTokenFilter { Stopwords = new [] { "stop1", "stop2" } })
+						.Add("myTokenFilter1", new StopTokenFilter { Stopwords = new[] { "stop1", "stop2" } })
 					)
 					.CharFilters(t => t
 						.Add("htmlFilter", new HtmlStripCharFilter())
@@ -317,7 +316,7 @@ public void PutMapping()
 			};
 			mapping.Properties.Add(fieldName, property);
 
-			var response = this.Client.Map<ElasticsearchProject>(m=>m.InitializeUsing(mapping));
+			var response = this.Client.Map<ElasticsearchProject>(m => m.InitializeUsing(mapping));
 
 			Assert.IsTrue(response.IsValid, response.ConnectionStatus.ToString());
 			Assert.IsTrue(response.Acknowledged, response.ConnectionStatus.ToString());
@@ -358,16 +357,16 @@ public void CreateIndexMultiFieldMap()
 			settings.Analysis.Analyzers.Add("snowball", new SnowballAnalyzer { Language = "English" });
 
 			var indexName = Guid.NewGuid().ToString();
-			var response = client.CreateIndex(indexName, i=>i.InitializeUsing(settings));
+			var response = client.CreateIndex(indexName, i => i.InitializeUsing(settings));
 
 			Assert.IsTrue(response.IsValid);
 			Assert.IsTrue(response.Acknowledged);
 
 			var inferrer = new ElasticInferrer(this.Settings);
 			var typeName = inferrer.PropertyName(typeMapping.Name);
-			Assert.IsNotNull(this.Client.GetMapping<ElasticsearchProject>(gm=>gm.Index(indexName).Type(typeName)));
+			Assert.IsNotNull(this.Client.GetMapping<ElasticsearchProject>(gm => gm.Index(indexName).Type(typeName)));
 
-			var deleteResponse = client.DeleteIndex(i=>i.Index(indexName));
+			var deleteResponse = client.DeleteIndex(i => i.Index(indexName));
 
 			Assert.IsTrue(deleteResponse.IsValid);
 			Assert.IsTrue(deleteResponse.Acknowledged);
diff --git a/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj b/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
index 469d22dcf01..ce5670b84e1 100644
--- a/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
+++ b/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
@@ -146,6 +146,7 @@
     <Compile Include="Indices\Analysis\Analyzers\AnalyzerTests.cs" />
     <Compile Include="Cluster\StateTests.cs" />
     <Compile Include="Core\Exists\TypeExistsTests.cs" />
+    <Compile Include="Indices\GetIndexTests.cs" />
     <Compile Include="Indices\StatusTests.cs" />
     <Compile Include="IntegrationTests.cs" />
     <Compile Include="Cluster\HealthTests.cs" />
diff --git a/src/Tests/Nest.Tests.Unit/BigBadUrlUnitTests.cs b/src/Tests/Nest.Tests.Unit/BigBadUrlUnitTests.cs
index df3a4868aec..5788eb26695 100644
--- a/src/Tests/Nest.Tests.Unit/BigBadUrlUnitTests.cs
+++ b/src/Tests/Nest.Tests.Unit/BigBadUrlUnitTests.cs
@@ -46,18 +46,17 @@ public void TestAllTheUrls()
 			Do("POST", "/_aliases", c => c.Alias(a => a));
 			Do("POST", "/_analyze", c => c.Analyze(a => a.Text("blah")));
 			Do("POST", "/myindex/_analyze", c => c.Analyze(a => a.Index("myindex").Text("blah")));
-			Do("POST", "/myindex/_bulk", c => c.Bulk(b => b.FixedPath("myindex").Index<Doc>(ib => ib.Document(new Doc { Id = "1" }))));
-			Do("POST", "/myindex/mytype/_bulk", c => c.Bulk(b => b.FixedPath("myindex", "mytype").Index<Doc>(ib => ib.Document(new Doc { Id = "1" }))));
-			Do("POST", "/myindex/_bulk", c => c.Bulk(b => b.FixedPath("myindex").Index<Doc>(ib => ib.Document(new Doc { Id = "1" }))));
-			Do("POST", "/_bulk", c => c.Bulk(b => b.Index<Doc>(ib => ib.Document(new Doc { Id = "1" }))));
+			Do("POST", "/myindex/_bulk", c => c.Bulk(b => b.FixedPath("myindex").Index<Doc>(ib => ib.Document(new Doc {Id = "1"}))));
+			Do("POST", "/myindex/mytype/_bulk", c => c.Bulk(b => b.FixedPath("myindex", "mytype").Index<Doc>(ib => ib.Document(new Doc {Id = "1"}))));
+			Do("POST", "/myindex/_bulk", c => c.Bulk(b => b.FixedPath("myindex").Index<Doc>(ib => ib.Document(new Doc {Id = "1"}))));
+			Do("POST", "/_bulk", c => c.Bulk(b => b.Index<Doc>(ib => ib.Document(new Doc {Id = "1"}))));
 			Do("POST", "/_cache/clear", c => c.ClearCache());
 			Do("POST", "/mydefaultindex/_cache/clear", c => c.ClearCache(cc => cc.Index<Doc>()));
 			Do("POST", "/mydefaultindex/_close", c => c.CloseIndex(ci => ci.Index<Doc>()));
 			Do("GET", "/_nodes", c => c.NodesInfo());
 			Do("GET", "/_nodes/insert-marvel-character", c => c.NodesInfo(cn => cn.NodeId("insert-marvel-character")));
 			Do("GET", "/_nodes/stats", c => c.NodesStats());
-			Do("GET", "/_nodes/insert-marvel-character/stats/jvm", c => c
-				.NodesStats(cn => cn.NodeId("insert-marvel-character").Metrics(NodesStatsMetric.Jvm)));
+			Do("GET", "/_nodes/insert-marvel-character/stats/jvm", c => c .NodesStats(cn => cn.NodeId("insert-marvel-character").Metrics(NodesStatsMetric.Jvm)));
 			Do("GET", "/_cluster/state", c => c.ClusterState());
 			Do("GET", "/_cluster/state?local=true", c => c.ClusterState(cs => cs.Local()));
 			Do("GET", "/_count", c => c.Count());
@@ -78,8 +77,10 @@ public void TestAllTheUrls()
 			Do("DELETE", "/custom-index/_query", c => c.DeleteByQuery<Doc>(q => q.Index("custom-index").AllTypes().MatchAll()));
 			Do("DELETE", "/mydefaultindex", c => c.DeleteIndex(i => i.Index<Doc>()));
 			Do("DELETE", "/a%2Cb", c => c.DeleteIndex(i => i.Indices("a", "b")));
-			Do("POST", "/_bulk", c => c.DeleteMany(Enumerable.Range(0, 10).Select(i => new Doc { Id = i.ToString() })));
-			Do("POST", "/customindex/customtype/_bulk", c => c.DeleteMany(Enumerable.Range(0, 10).Select(i => new Doc { Id = i.ToString() }), index: "customindex", type: "customtype"));
+			Do("POST", "/_bulk", c => c.DeleteMany(Enumerable.Range(0, 10).Select(i => new Doc {Id = i.ToString()})));
+			Do("POST", "/customindex/customtype/_bulk", c =>
+					c.DeleteMany(Enumerable.Range(0, 10).Select(i => new Doc {Id = i.ToString()}), index: "customindex",
+						type: "customtype"));
 			Do("DELETE", "/mydefaultindex/doc/_mapping", c => c.DeleteMapping<Doc>());
 			Do("DELETE", "/_template/myTemplate", c => c.DeleteTemplate("myTemplate"));
 			Do("DELETE", "/_all/_warmer/mywarmer", c => c.DeleteWarmer("mywarmer", w => w.AllIndices()));
@@ -103,24 +104,27 @@ public void TestAllTheUrls()
 			Do("GET", "/mycustomindex/_warmer/mywarmer", c => c.GetWarmer("mywarmer", g => g.Index("mycustomindex")));
 			Do("GET", "/_cluster/health?level=indices", c => c.ClusterHealth(h => h.Level(Level.Indices)));
 			Do("GET", "/_cluster/health", c => c.ClusterHealth());
-			Do("PUT", "/mydefaultindex/doc/2", c => c.Index(new Doc { Id = "2" }));
-			Do("POST", "/mydefaultindex/doc", c => c.Index(new Doc { Name = "2" }));
-			Do("PUT", "/customindex/customtype/2?refresh=true", c => c.Index(new Doc { Id = "2" }, i => i.Index("customindex").Type("customtype").Refresh()));
+			Do("PUT", "/mydefaultindex/doc/2", c => c.Index(new Doc {Id = "2"}));
+			Do("POST", "/mydefaultindex/doc", c => c.Index(new Doc {Name = "2"}));
+			Do("PUT", "/customindex/customtype/2?refresh=true",
+				c => c.Index(new Doc {Id = "2"}, i => i.Index("customindex").Type("customtype").Refresh()));
 			Do("HEAD", "/mydefaultindex", c => c.IndexExists(h => h.Index<Doc>()));
 			Do("HEAD", "/mydefaultindex/_alias/myalias", c => c.AliasExists(h => h.Index<Doc>().Name("myalias")));
 			Do("HEAD", "/mydefaultindex/some-type", c => c.TypeExists(h => h.Index<Doc>().Type("some-type")));
 			Do("HEAD", "/_alias/myalias", c => c.AliasExists(new AliasExistsRequest("myalias")));
-			Do("POST", "/_bulk", c => c.IndexMany(Enumerable.Range(0, 10).Select(i => new Doc { Id = i.ToString() })));
-			Do("POST", "/customindex/customtype/_bulk", c => c.IndexMany(Enumerable.Range(0, 10).Select(i => new Doc { Id = i.ToString() }), index: "customindex", type: "customtype"));
+			Do("POST", "/_bulk", c => c.IndexMany(Enumerable.Range(0, 10).Select(i => new Doc {Id = i.ToString()})));
+			Do("POST", "/customindex/customtype/_bulk", c =>
+					c.IndexMany(Enumerable.Range(0, 10).Select(i => new Doc {Id = i.ToString()}), index: "customindex",
+						type: "customtype"));
 			Do("GET", "/_stats", c => c.IndicesStats());
 			Do("GET", "/my_index/_stats", c => c.IndicesStats(s => s.Index("my_index")));
-			Do("GET", "/my_index/_stats?types=type1", c => c.IndicesStats(s => s.Index("my_index").Types(new TypeNameMarker[] { "type1" })));
-			Do("GET", "/my_index/_stats?types=type1%2Ctype2", c => c.IndicesStats(s => s.Index("my_index").Types(new TypeNameMarker[] { "type1", "type2" })));
+			Do("GET", "/my_index/_stats?types=type1", c => c.IndicesStats(s => s.Index("my_index").Types(new TypeNameMarker[] {"type1"})));
+			Do("GET", "/my_index/_stats?types=type1%2Ctype2", c => c.IndicesStats(s => s.Index("my_index").Types(new TypeNameMarker[] {"type1", "type2"})));
 			Do("GET", "/mydefaultindex/_stats", c => c.IndicesStats(s => s.Index<Doc>()));
 			Do("PUT", "/mydefaultindex/doc/_mapping", c => c.Map<Doc>(m => m.MapFromAttributes()));
 			Do("PUT", "/mycustomindex/doc/_mapping", c => c.Map<Doc>(m => m.Index("mycustomindex")));
 			Do("PUT", "/mycustomindex/customtype/_mapping", c => c.Map<Doc>(m => m.Index("mycustomindex").Type("customtype")));
-			Do("GET", "/mydefaultindex/doc/1/_mlt", c => c.MoreLikeThis<Doc>(m => m.IdFrom(new Doc { Id = "1" })));
+			Do("GET", "/mydefaultindex/doc/1/_mlt", c => c.MoreLikeThis<Doc>(m => m.IdFrom(new Doc {Id = "1"})));
 			Do("GET", "/mydefaultindex/doc/1/_mlt", c => c.MoreLikeThis<Doc>(m => m.Id(1)));
 			Do("GET", "/mycustomindex/mycustomtype/1/_mlt", c => c.MoreLikeThis<Doc>(m => m.Id(1).Index("mycustomindex").Type("mycustomtype")));
 			Do("POST", "/_msearch", c => c.MultiSearch(m => m.Search<Doc>(s => s.MatchAll())));
@@ -133,7 +137,8 @@ public void TestAllTheUrls()
 			Do("POST", "/mydefaultindex/_optimize", c => c.Optimize(o => o.Index<Doc>()));
 			Do("POST", "/mydefaultindex/doc/_percolate", c => c.Percolate<Doc>(p => p.Document(new Doc { Id = "1" })));
 			Do("POST", "/mydefaultindex/otherdoc/_percolate", c => c.Percolate<OtherDoc>(p => p.Document(new OtherDoc { Name = "hello" })));
-			Do("POST", "/mycustomindex/mycustomtype/_percolate", c => c.Percolate<OtherDoc>(p => p.Document(new OtherDoc { Name = "hello" }).Index("mycustomindex").Type("mycustomtype")));
+			Do("POST", "/mycustomindex/mycustomtype/_percolate", 
+				c => c.Percolate<OtherDoc>(p => p.Document(new OtherDoc {Name = "hello"}).Index("mycustomindex").Type("mycustomtype")));
 			Do("POST", "/mydefaultindex/otherdoc/my-id/_percolate", c => c.Percolate<OtherDoc>(p => p.Id("my-id")));
 			Do("POST", "/mydefaultindex/otherdoc/my-id/_explain", c => c.Explain<OtherDoc>(p => p.Id("my-id")));
 
@@ -161,8 +166,8 @@ public void TestAllTheUrls()
 			Do("GET", "/mydefaultindex/_status", c => c.Status(s => s.Index<Doc>()));
 			Do("DELETE", "/mydefaultindex/.percolator/mypercolator", c => c.UnregisterPercolator<ElasticsearchProject>("mypercolator"));
 			Do("DELETE", "/mycustomindex/.percolator/mypercolator", c => c.UnregisterPercolator<ElasticsearchProject>("mypercolator", r => r.Index("mycustomindex")));
-			Do("POST", "/mydefaultindex/doc/1/_update", c => c.Update<Doc, OtherDoc>(u => u.Id(1).Doc(new OtherDoc { Name = "asd" })));
-			Do("POST", "/mydefaultindex/customtype/1/_update", c => c.Update<Doc, OtherDoc>(u => u.Id(1).Type("customtype").Doc(new OtherDoc { Name = "asd" })));
+			Do("POST", "/mydefaultindex/doc/1/_update", c => c.Update<Doc, OtherDoc>(u => u.Id(1).Doc(new OtherDoc {Name = "asd"})));
+			Do("POST", "/mydefaultindex/customtype/1/_update", c => c.Update<Doc, OtherDoc>(u => u.Id(1).Type("customtype").Doc(new OtherDoc {Name = "asd"})));
 			Do("PUT", "/mydefaultindex/_settings", c => c.UpdateSettings(u => u.AutoExpandReplicas(false)));
 			Do("PUT", "/mycustomindex/_settings", c => c.UpdateSettings(u => u.Index("mycustomindex").AutoExpandReplicas(false)));
 			Do("POST", "/_all/doc/_validate/query", c => c.Validate<Doc>(v => v.AllIndices()));
@@ -181,6 +186,9 @@ public void TestAllTheUrls()
 			Do("POST", "/_scripts/lang/id", c => c.PutScript(s => s.Lang("lang").Id("id")));
 			Do("GET", "/_scripts/lang/id", c => c.GetScript(s => s.Lang("lang").Id("id")));
 			Do("DELETE", "/_scripts/lang/id", c => c.DeleteScript(s => s.Lang("lang").Id("id")));
+			Do("GET", "/_all/_mappings%2C_aliases", c => c.GetIndex(d => d.AllIndices().Features(GetIndexFeature.Aliases | GetIndexFeature.Mappings)));
+			Do("GET", "/_all", c => c.GetIndex(d => d.AllIndices().Features(GetIndexFeature.All)));
+			Do("GET", "/_all", c => c.GetIndex(d => d.AllIndices()));
 
 			Do("GET", "/mydefaultindex/doc/_search/exists?q=term", c => c.SearchExists<Doc>(s => s.QueryString("term")));
 			Do("GET", "/mydefaultindex/doc/_search/exists?source=%7B%7D", c => c.SearchExists<Doc>(s=>s.Source("{}")));
@@ -188,7 +196,10 @@ public void TestAllTheUrls()
 			Do("POST", "/mydefaultindex/doc/_search/exists", c => c.SearchExists<Doc>(s=>s.Query(q=>q.MatchAll())));
 
 			Do("POST", "/_snapshot/my_repos/_verify", c => c.VerifyRepository("my_repos"));
-		}
+			Do("GET", "/mydefaultindex/_settings%2C_mappings", c => c.GetIndex(d => d.Index<OtherDoc>().Features(GetIndexFeature.Settings | GetIndexFeature.Mappings)));
+			Do("GET", "/x%2Cy", c => c.GetIndex(d => d.Indices("x", "y").Features(GetIndexFeature.All)));
+			Do("GET", "/x%2Cy", c => c.GetIndex(d => d.Indices("x", "y")));
 
+		}
 	}
 }
\ No newline at end of file