diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Overrides/Descriptors/SearchDescriptorOverrides.cs b/src/CodeGeneration/CodeGeneration.LowLevelClient/Overrides/Descriptors/SearchDescriptorOverrides.cs
index e7e5bbd0631..5fcb1bdfee0 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Overrides/Descriptors/SearchDescriptorOverrides.cs
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Overrides/Descriptors/SearchDescriptorOverrides.cs
@@ -25,7 +25,8 @@ public IEnumerable<string> SkipQueryStringParams
 					"sort",
 					"_source",
 					"_source_include",
-					"_source_exclude"
+					"_source_exclude",
+					"track_scores"
 				};
 			}
 		}
diff --git a/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs b/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs
index 6fb1721bb92..e743ae7565b 100644
--- a/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs
+++ b/src/Elasticsearch.Net/Domain/RequestParameters/RequestParameters.Generated.cs
@@ -1683,6 +1683,26 @@ public DeleteByQueryRequestParameters Timeout(string timeout)
 	}
 	
 	
+	///<summary>Request parameters descriptor for DeleteScript
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+	///</pre>
+	///</summary>
+	public class DeleteScriptRequestParameters : FluentRequestParameters<DeleteScriptRequestParameters> 
+	{
+	}
+	
+	
+	///<summary>Request parameters descriptor for DeleteTemplate
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+	///</pre>
+	///</summary>
+	public class DeleteTemplateRequestParameters : FluentRequestParameters<DeleteTemplateRequestParameters> 
+	{
+	}
+	
+	
 	///<summary>Request parameters descriptor for Exists
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
@@ -2043,6 +2063,16 @@ public GetRequestParameters VersionType(VersionType version_type)
 	}
 	
 	
+	///<summary>Request parameters descriptor for GetScript
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+	///</pre>
+	///</summary>
+	public class GetScriptRequestParameters : FluentRequestParameters<GetScriptRequestParameters> 
+	{
+	}
+	
+	
 	///<summary>Request parameters descriptor for GetSource
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
@@ -2163,6 +2193,16 @@ public SourceRequestParameters VersionType(VersionType version_type)
 	}
 	
 	
+	///<summary>Request parameters descriptor for GetTemplate
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+	///</pre>
+	///</summary>
+	public class GetTemplateRequestParameters : FluentRequestParameters<GetTemplateRequestParameters> 
+	{
+	}
+	
+	
 	///<summary>Request parameters descriptor for Index
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html
@@ -2683,36 +2723,6 @@ public DeleteMappingRequestParameters MasterTimeout(string master_timeout)
 	}
 	
 	
-	///<summary>Request parameters descriptor for IndicesDeleteTemplateForAll
-	///<pre>
-	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
-	///</pre>
-	///</summary>
-	public class DeleteTemplateRequestParameters : FluentRequestParameters<DeleteTemplateRequestParameters> 
-	{
-		
-		internal string _timeout { get; set; }
-		///<summary>Explicit operation timeout</summary>
-		public DeleteTemplateRequestParameters Timeout(string timeout)
-		{
-			this._timeout = timeout;
-			this.AddQueryString("timeout", this._timeout);
-			return this;
-		}
-		
-		
-		internal string _master_timeout { get; set; }
-		///<summary>Specify timeout for connection to master</summary>
-		public DeleteTemplateRequestParameters MasterTimeout(string master_timeout)
-		{
-			this._master_timeout = master_timeout;
-			this.AddQueryString("master_timeout", this._master_timeout);
-			return this;
-		}
-		
-	}
-	
-	
 	///<summary>Request parameters descriptor for IndicesDeleteWarmer
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
@@ -3213,36 +3223,6 @@ public GetIndexSettingsRequestParameters Local(bool local)
 	}
 	
 	
-	///<summary>Request parameters descriptor for IndicesGetTemplateForAll
-	///<pre>
-	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
-	///</pre>
-	///</summary>
-	public class GetTemplateRequestParameters : FluentRequestParameters<GetTemplateRequestParameters> 
-	{
-		
-		internal bool _flat_settings { get; set; }
-		///<summary>Return settings in flat format (default: false)</summary>
-		public GetTemplateRequestParameters FlatSettings(bool flat_settings)
-		{
-			this._flat_settings = flat_settings;
-			this.AddQueryString("flat_settings", this._flat_settings);
-			return this;
-		}
-		
-		
-		internal bool _local { get; set; }
-		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public GetTemplateRequestParameters Local(bool local)
-		{
-			this._local = local;
-			this.AddQueryString("local", this._local);
-			return this;
-		}
-		
-	}
-	
-	
 	///<summary>Request parameters descriptor for IndicesGetWarmerForAll
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
@@ -3621,6 +3601,16 @@ public UpdateSettingsRequestParameters FlatSettings(bool flat_settings)
 	public class PutTemplateRequestParameters : FluentRequestParameters<PutTemplateRequestParameters> 
 	{
 		
+		internal bool _create { get; set; }
+		///<summary>Whether the index template should only be added if new or can also replace an existing one</summary>
+		public PutTemplateRequestParameters Create(bool create)
+		{
+			this._create = create;
+			this.AddQueryString("create", this._create);
+			return this;
+		}
+		
+		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
 		public PutTemplateRequestParameters Timeout(string timeout)
@@ -3901,9 +3891,9 @@ public IndicesStatsRequestParameters Fields(params string[] fields)
 		}
 		
 		
-		internal bool _groups { get; set; }
+		internal  string[] _groups { get; set; }
 		///<summary>A comma-separated list of search groups for `search` index metric</summary>
-		public IndicesStatsRequestParameters Groups(bool groups)
+		public IndicesStatsRequestParameters Groups(params string[] groups)
 		{
 			this._groups = groups;
 			this.AddQueryString("groups", this._groups);
@@ -4893,6 +4883,16 @@ public class PingRequestParameters : FluentRequestParameters<PingRequestParamete
 	}
 	
 	
+	///<summary>Request parameters descriptor for PutScript
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+	///</pre>
+	///</summary>
+	public class PutScriptRequestParameters : FluentRequestParameters<PutScriptRequestParameters> 
+	{
+	}
+	
+	
 	///<summary>Request parameters descriptor for ScrollGet
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
diff --git a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
index 27ccedbf40f..258985436f6 100644
--- a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
@@ -7913,6 +7913,294 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string
 			));
 		}
 		
+		///<summary>Represents a DELETE on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> DeleteScript<T>(string lang, string id, Func<DeleteScriptRequestParameters, DeleteScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new DeleteScriptRequestParameters());
+			}
+				
+
+
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a DELETE on /_scripts/{lang}/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> DeleteScriptAsync<T>(string lang, string id, Func<DeleteScriptRequestParameters, DeleteScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new DeleteScriptRequestParameters());
+			}
+				
+
+
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a DELETE on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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> DeleteScript(string lang, string id, Func<DeleteScriptRequestParameters, DeleteScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new DeleteScriptRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a DELETE on /_scripts/{lang}/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>> DeleteScriptAsync(string lang, string id, Func<DeleteScriptRequestParameters, DeleteScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new DeleteScriptRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a DELETE on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> DeleteTemplate<T>(string id, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new DeleteTemplateRequestParameters());
+			}
+				
+
+
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a DELETE on /_search/template/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> DeleteTemplateAsync<T>(string id, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new DeleteTemplateRequestParameters());
+			}
+				
+
+
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a DELETE on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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> DeleteTemplate(string id, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new DeleteTemplateRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a DELETE on /_search/template/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>> DeleteTemplateAsync(string id, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new DeleteTemplateRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
+			));
+		}
+		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
@@ -8565,15 +8853,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, str
 			));
 		}
 		
-		///<summary>Represents a GET on /{index}/{type}/{id}/_source
+		///<summary>Represents a GET on /_scripts/{lang}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
 		///<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>
-	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html</para>	
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
 	    ///</summary>
-		///<param name="index">The name of the index</param>
-		///<param name="type">The type of the document; use `_all` to fetch the first document matching the ID across all types</param>
-		///<param name="id">The document ID</param>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
 		///<param name="requestParameters">
 		///Optional function to specify any additional request parameters 
 		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
@@ -8582,17 +8869,16 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, str
 		///<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> GetSource<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<T> GetScript<T>(string lang, string id, Func<GetScriptRequestParameters, GetScriptRequestParameters> requestParameters = null)
 		{
-			index.ThrowIfNullOrEmpty("index");
-			type.ThrowIfNullOrEmpty("type");
+			lang.ThrowIfNullOrEmpty("lang");
 			id.ThrowIfNullOrEmpty("id");
-			var url = "{0}/{1}/{2}/_source".F(Encoded(index), Encoded(type), Encoded(id));
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
 			IRequestParameters requestParams = null;
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new SourceRequestParameters());
+				requestParams = requestParameters(new GetScriptRequestParameters());
 			}
 				
 
@@ -8603,15 +8889,14 @@ public ElasticsearchResponse<T> GetSource<T>(string index, string type, string i
 			);
 		}
 		
-		///<summary>Represents a GET on /{index}/{type}/{id}/_source
+		///<summary>Represents a GET on /_scripts/{lang}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
 		///<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>
-	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html</para>	
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
 	    ///</summary>
-		///<param name="index">The name of the index</param>
-		///<param name="type">The type of the document; use `_all` to fetch the first document matching the ID across all types</param>
-		///<param name="id">The document ID</param>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
 		///<param name="requestParameters">
 		///Optional function to specify any additional request parameters 
 		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
@@ -8620,17 +8905,168 @@ public ElasticsearchResponse<T> GetSource<T>(string index, string type, string i
 		///<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>> GetSourceAsync<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<T>> GetScriptAsync<T>(string lang, string id, Func<GetScriptRequestParameters, GetScriptRequestParameters> requestParameters = null)
 		{
-			index.ThrowIfNullOrEmpty("index");
-			type.ThrowIfNullOrEmpty("type");
+			lang.ThrowIfNullOrEmpty("lang");
 			id.ThrowIfNullOrEmpty("id");
-			var url = "{0}/{1}/{2}/_source".F(Encoded(index), Encoded(type), Encoded(id));
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
 			IRequestParameters requestParams = null;
 				
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new SourceRequestParameters());
+				requestParams = requestParameters(new GetScriptRequestParameters());
+			}
+				
+
+
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a GET on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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> GetScript(string lang, string id, Func<GetScriptRequestParameters, GetScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new GetScriptRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a GET on /_scripts/{lang}/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>> GetScriptAsync(string lang, string id, Func<GetScriptRequestParameters, GetScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new GetScriptRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a GET on /{index}/{type}/{id}/_source
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html</para>	
+	    ///</summary>
+		///<param name="index">The name of the index</param>
+		///<param name="type">The type of the document; use `_all` to fetch the first document matching the ID across all types</param>
+		///<param name="id">The document ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> GetSource<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> requestParameters = null)
+		{
+			index.ThrowIfNullOrEmpty("index");
+			type.ThrowIfNullOrEmpty("type");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "{0}/{1}/{2}/_source".F(Encoded(index), Encoded(type), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new SourceRequestParameters());
+			}
+				
+
+
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a GET on /{index}/{type}/{id}/_source
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html</para>	
+	    ///</summary>
+		///<param name="index">The name of the index</param>
+		///<param name="type">The type of the document; use `_all` to fetch the first document matching the ID across all types</param>
+		///<param name="id">The document ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> GetSourceAsync<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> requestParameters = null)
+		{
+			index.ThrowIfNullOrEmpty("index");
+			type.ThrowIfNullOrEmpty("type");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "{0}/{1}/{2}/_source".F(Encoded(index), Encoded(type), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new SourceRequestParameters());
 			}
 				
 
@@ -8715,6 +9151,146 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string inde
 				
 
 
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a GET on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> GetTemplate<T>(string id, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+			}
+				
+
+
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a GET on /_search/template/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> GetTemplateAsync<T>(string id, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+			}
+				
+
+
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a GET on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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> GetTemplate(string id, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a GET on /_search/template/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>> GetTemplateAsync(string id, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+			}
+				
+
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30205,6 +30781,598 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingRequest
 			));
 		}
 		
+		///<summary>Represents a PUT on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> PutScript<T>(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutScriptRequestParameters());
+			}
+				
+
+
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a PUT on /_scripts/{lang}/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> PutScriptAsync<T>(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutScriptRequestParameters());
+			}
+				
+
+
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a PUT on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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> PutScript(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutScriptRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a PUT on /_scripts/{lang}/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>> PutScriptAsync(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutScriptRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a POST on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> PutScriptPost<T>(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutScriptRequestParameters());
+			}
+				
+
+
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a POST on /_scripts/{lang}/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> PutScriptPostAsync<T>(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutScriptRequestParameters());
+			}
+				
+
+
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a POST on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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> PutScriptPost(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutScriptRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a POST on /_scripts/{lang}/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+	    ///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>> PutScriptPostAsync(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null)
+		{
+			lang.ThrowIfNullOrEmpty("lang");
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_scripts/{0}/{1}".F(Encoded(lang), Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutScriptRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a PUT on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> PutTemplate<T>(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+			}
+				
+
+
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a PUT on /_search/template/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> PutTemplateAsync<T>(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+			}
+				
+
+
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a PUT on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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> PutTemplate(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a PUT on /_search/template/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>> PutTemplateAsync(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a POST on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> PutTemplatePost<T>(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+			}
+				
+
+
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a POST on /_search/template/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> PutTemplatePostAsync<T>(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+			}
+				
+
+
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
+			);
+		}
+		
+		///<summary>Represents a POST on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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> PutTemplatePost(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
+			));
+		}
+		
+		///<summary>Represents a POST on /_search/template/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+	    ///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>> PutTemplatePostAsync(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
+		{
+			id.ThrowIfNullOrEmpty("id");
+			var url = "_search/template/{0}".F(Encoded(id));
+			IRequestParameters requestParams = null;
+				
+			if (requestParameters != null)
+			{
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+			}
+				
+
+
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
+			));
+		}
+		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
diff --git a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
index 9122c685abf..38c3b6feceb 100644
--- a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
@@ -4072,6 +4072,162 @@ public interface IElasticsearchClient
 		
 		Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null);
 		
+		///<summary>Represents a DELETE on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		ElasticsearchResponse<T> DeleteScript<T>(string lang, string id, Func<DeleteScriptRequestParameters, DeleteScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a DELETE on /_scripts/{lang}/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		Task<ElasticsearchResponse<T>> DeleteScriptAsync<T>(string lang, string id, Func<DeleteScriptRequestParameters, DeleteScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a DELETE on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		ElasticsearchResponse<DynamicDictionary> DeleteScript(string lang, string id, Func<DeleteScriptRequestParameters, DeleteScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a DELETE on /_scripts/{lang}/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		Task<ElasticsearchResponse<DynamicDictionary>> DeleteScriptAsync(string lang, string id, Func<DeleteScriptRequestParameters, DeleteScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a DELETE on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		ElasticsearchResponse<T> DeleteTemplate<T>(string id, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a DELETE on /_search/template/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		Task<ElasticsearchResponse<T>> DeleteTemplateAsync<T>(string id, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a DELETE on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		ElasticsearchResponse<DynamicDictionary> DeleteTemplate(string id, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a DELETE on /_search/template/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		Task<ElasticsearchResponse<DynamicDictionary>> DeleteTemplateAsync(string id, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null);
+		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
@@ -4412,6 +4568,86 @@ public interface IElasticsearchClient
 		
 		Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> requestParameters = null);
 		
+		///<summary>Represents a GET on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		ElasticsearchResponse<T> GetScript<T>(string lang, string id, Func<GetScriptRequestParameters, GetScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a GET on /_scripts/{lang}/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		Task<ElasticsearchResponse<T>> GetScriptAsync<T>(string lang, string id, Func<GetScriptRequestParameters, GetScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a GET on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		ElasticsearchResponse<DynamicDictionary> GetScript(string lang, string id, Func<GetScriptRequestParameters, GetScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a GET on /_scripts/{lang}/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		Task<ElasticsearchResponse<DynamicDictionary>> GetScriptAsync(string lang, string id, Func<GetScriptRequestParameters, GetScriptRequestParameters> requestParameters = null);
+		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_source
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
@@ -4496,6 +4732,82 @@ public interface IElasticsearchClient
 		
 		Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> requestParameters = null);
 		
+		///<summary>Represents a GET on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		ElasticsearchResponse<T> GetTemplate<T>(string id, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a GET on /_search/template/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		Task<ElasticsearchResponse<T>> GetTemplateAsync<T>(string id, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a GET on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		ElasticsearchResponse<DynamicDictionary> GetTemplate(string id, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a GET on /_search/template/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		Task<ElasticsearchResponse<DynamicDictionary>> GetTemplateAsync(string id, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
+		
 		///<summary>Represents a POST on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
@@ -16156,6 +16468,334 @@ public interface IElasticsearchClient
 		
 		Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingRequestParameters, PingRequestParameters> requestParameters = null);
 		
+		///<summary>Represents a PUT on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		ElasticsearchResponse<T> PutScript<T>(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a PUT on /_scripts/{lang}/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		Task<ElasticsearchResponse<T>> PutScriptAsync<T>(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a PUT on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		ElasticsearchResponse<DynamicDictionary> PutScript(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a PUT on /_scripts/{lang}/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		Task<ElasticsearchResponse<DynamicDictionary>> PutScriptAsync(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a POST on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		ElasticsearchResponse<T> PutScriptPost<T>(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a POST on /_scripts/{lang}/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		Task<ElasticsearchResponse<T>> PutScriptPostAsync<T>(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a POST on /_scripts/{lang}/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		ElasticsearchResponse<DynamicDictionary> PutScriptPost(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a POST on /_scripts/{lang}/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html</para>	
+		///</summary>
+		///<param name="lang">Script language</param>
+		///<param name="id">Script ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		Task<ElasticsearchResponse<DynamicDictionary>> PutScriptPostAsync(string lang, string id, object body, Func<PutScriptRequestParameters, PutScriptRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a PUT on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		ElasticsearchResponse<T> PutTemplate<T>(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a PUT on /_search/template/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		Task<ElasticsearchResponse<T>> PutTemplateAsync<T>(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a PUT on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		ElasticsearchResponse<DynamicDictionary> PutTemplate(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a PUT on /_search/template/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		Task<ElasticsearchResponse<DynamicDictionary>> PutTemplateAsync(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a POST on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		ElasticsearchResponse<T> PutTemplatePost<T>(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a POST on /_search/template/{id}
+		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>
+		
+		Task<ElasticsearchResponse<T>> PutTemplatePostAsync<T>(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a POST on /_search/template/{id}
+		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		ElasticsearchResponse<DynamicDictionary> PutTemplatePost(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
+		
+		///<summary>Represents a POST on /_search/template/{id}
+		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html</para>	
+		///</summary>
+		///<param name="id">Template ID</param>
+		///<param name="body">The document</param>
+		///<param name="requestParameters">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>
+		///<returns>Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
+		///<para> - Dynamic dictionary is a special dynamic type that allows json to be traversed safely</para>
+		///<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>
+		
+		Task<ElasticsearchResponse<DynamicDictionary>> PutTemplatePostAsync(string id, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
+		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
diff --git a/src/Nest/DSL/DeleteSearchTemplateDescriptor.cs b/src/Nest/DSL/DeleteSearchTemplateDescriptor.cs
new file mode 100644
index 00000000000..03a5d4757a9
--- /dev/null
+++ b/src/Nest/DSL/DeleteSearchTemplateDescriptor.cs
@@ -0,0 +1,44 @@
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public interface IDeleteSearchTemplateRequest : INamePath<DeleteTemplateRequestParameters> { }
+
+	public partial class DeleteSearchTemplateRequest 
+		: NamePathBase<DeleteTemplateRequestParameters>, IDeleteSearchTemplateRequest
+	{
+		public DeleteSearchTemplateRequest(string templateName)
+			: base(templateName)
+		{
+		}
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo)
+		{
+			DeleteSearchTemplatePathInfo.Update(pathInfo, this);
+		}
+	}
+
+	internal static class DeleteSearchTemplatePathInfo
+	{
+		public static void Update(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo, IDeleteSearchTemplateRequest request)
+		{
+			pathInfo.Id = request.Name;
+			pathInfo.HttpMethod = PathInfoHttpMethod.DELETE;
+		}
+	}
+
+	public partial class DeleteSearchTemplateDescriptor 
+		: NamePathDescriptor<DeleteSearchTemplateDescriptor, DeleteTemplateRequestParameters>, IDeleteSearchTemplateRequest
+	{
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo)
+		{
+			DeleteSearchTemplatePathInfo.Update(pathInfo, this);
+		}
+	}
+}
diff --git a/src/Nest/DSL/GetSearchTemplateDescriptor.cs b/src/Nest/DSL/GetSearchTemplateDescriptor.cs
new file mode 100644
index 00000000000..dd54f9a127a
--- /dev/null
+++ b/src/Nest/DSL/GetSearchTemplateDescriptor.cs
@@ -0,0 +1,46 @@
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public interface IGetSearchTemplateRequest : INamePath<GetTemplateRequestParameters>
+	{
+	}
+
+	public partial class GetSearchTemplateRequest 
+		: NamePathBase<GetTemplateRequestParameters>, IGetSearchTemplateRequest
+	{
+		public GetSearchTemplateRequest(string templateName)
+			: base(templateName)
+		{
+		}
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo)
+		{
+			GetSearchTemplatePathInfo.Update(pathInfo, this);
+		}
+	}
+
+	internal static class GetSearchTemplatePathInfo
+	{
+		public static void Update(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo, IGetSearchTemplateRequest request)
+		{
+			pathInfo.Id = request.Name;
+			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
+		}
+	}
+
+	public partial class GetSearchTemplateDescriptor 
+		: NamePathDescriptor<GetSearchTemplateDescriptor, GetTemplateRequestParameters>, IGetSearchTemplateRequest
+	{
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo)
+		{
+			GetSearchTemplatePathInfo.Update(pathInfo, this);
+		}
+	}
+}
diff --git a/src/Nest/DSL/PutSearchTemplateDescriptor.cs b/src/Nest/DSL/PutSearchTemplateDescriptor.cs
new file mode 100644
index 00000000000..60c459fd0d8
--- /dev/null
+++ b/src/Nest/DSL/PutSearchTemplateDescriptor.cs
@@ -0,0 +1,59 @@
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public interface IPutSearchTemplateRequest : INamePath<PutTemplateRequestParameters>
+	{
+		[JsonProperty("template")]
+		string Template { get; set; }
+	}
+
+	public partial class PutSearchTemplateRequest : NamePathBase<PutTemplateRequestParameters>, IPutSearchTemplateRequest
+	{
+		public string Template { get; set; }
+
+		public PutSearchTemplateRequest(string templateName)
+			: base(templateName)
+		{
+		}
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo)
+		{
+			PutSearchTemplatePathInfo.Update(pathInfo, this);
+		}
+	}
+
+	internal static class PutSearchTemplatePathInfo
+	{
+		public static void Update(ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo, IPutSearchTemplateRequest request)
+		{
+			pathInfo.Id = request.Name;
+			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
+		}
+	}
+
+	[DescriptorFor("SearchTemplatePut")]
+	public partial class PutSearchTemplateDescriptor
+		: NamePathDescriptor<PutSearchTemplateDescriptor, PutTemplateRequestParameters>, IPutSearchTemplateRequest
+	{
+		IPutSearchTemplateRequest Self { get { return this; } }
+		string IPutSearchTemplateRequest.Template { get; set;}
+
+		public PutSearchTemplateDescriptor Template(string template)
+		{
+			this.Self.Template = template;
+			return this;
+		}
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo)
+		{
+			PutSearchTemplatePathInfo.Update(pathInfo, this);
+		}
+	}
+}
diff --git a/src/Nest/DSL/Query/IQueryContainer.cs b/src/Nest/DSL/Query/IQueryContainer.cs
index d5becbc8510..27605e2ee06 100644
--- a/src/Nest/DSL/Query/IQueryContainer.cs
+++ b/src/Nest/DSL/Query/IQueryContainer.cs
@@ -140,6 +140,9 @@ public interface IQueryContainer : ICustomJson
 		[JsonProperty(PropertyName = "function_score")]
 		IFunctionScoreQuery FunctionScore { get; set; }
 
+		[JsonProperty(PropertyName = "template")]
+		ITemplateQuery Template { get; set; }
+
 		void Accept(IQueryVisitor visitor);
 	}
 }
\ No newline at end of file
diff --git a/src/Nest/DSL/Query/QueryContainer.cs b/src/Nest/DSL/Query/QueryContainer.cs
index df938fa5ff7..9baf14d70ef 100644
--- a/src/Nest/DSL/Query/QueryContainer.cs
+++ b/src/Nest/DSL/Query/QueryContainer.cs
@@ -86,6 +86,8 @@ public class QueryContainer : IQueryContainer
 		IIndicesQuery IQueryContainer.Indices { get; set; }
 
 		IFunctionScoreQuery IQueryContainer.FunctionScore { get; set; }
+
+		ITemplateQuery IQueryContainer.Template { get; set; }
 		
 		public QueryContainer() {}
 		
diff --git a/src/Nest/DSL/Query/QueryDescriptor.cs b/src/Nest/DSL/Query/QueryDescriptor.cs
index 1b998f9ad37..ab5f39793f9 100644
--- a/src/Nest/DSL/Query/QueryDescriptor.cs
+++ b/src/Nest/DSL/Query/QueryDescriptor.cs
@@ -854,5 +854,12 @@ public QueryContainer FunctionScore(Action<FunctionScoreQueryDescriptor<T>> func
 			return this.New(query, q => q.FunctionScore = query);
 
 		}
+
+		public QueryContainer Template(Action<TemplateQueryDescriptor> selector)
+		{
+			var query = new TemplateQueryDescriptor();
+			selector(query);
+			return this.New(query, q => q.Template = query);
+		}
 	}
 }
diff --git a/src/Nest/DSL/Query/TemplateQueryDescriptor.cs b/src/Nest/DSL/Query/TemplateQueryDescriptor.cs
new file mode 100644
index 00000000000..6635d33c2bb
--- /dev/null
+++ b/src/Nest/DSL/Query/TemplateQueryDescriptor.cs
@@ -0,0 +1,66 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public interface ITemplateQuery : IQuery
+	{
+		[JsonProperty("query")]
+		string Query { get; set; }
+
+		[JsonProperty("params")]
+		IDictionary<string, object> Params { get; set; } 
+	}
+
+	public class TemplateQuery : PlainQuery, ITemplateQuery
+	{
+		protected override void WrapInContainer(IQueryContainer container)
+		{
+			container.Template = this;
+		}
+
+		public string Query { get; set; }
+
+		public IDictionary<string, object> Params { get; set;}
+
+		public bool IsConditionless
+		{
+			get { return this.Query.IsNullOrEmpty(); }
+		}
+	}
+
+	public class TemplateQueryDescriptor : ITemplateQuery
+	{
+		ITemplateQuery Self { get { return this; } }
+
+		string ITemplateQuery.Query { get; set; }
+
+		IDictionary<string, object> ITemplateQuery.Params { get; set; }
+
+		bool IQuery.IsConditionless { get { return this.Self.Query.IsNullOrEmpty(); } }
+
+		public TemplateQueryDescriptor Query(string query)
+		{
+			this.Self.Query = query;
+			return this;
+		}
+
+		public TemplateQueryDescriptor Params(IDictionary<string, object> paramsDictionary)
+		{
+			paramsDictionary.ThrowIfNull("paramsDictionary");
+			this.Self.Params = paramsDictionary;
+			return this;
+		}
+
+		public TemplateQueryDescriptor Params(Func<FluentDictionary<string, object>, FluentDictionary<string, object>> paramsDictionary)
+		{
+			paramsDictionary.ThrowIfNull("paramsDictionary");
+			this.Self.Params = paramsDictionary(new FluentDictionary<string,object>());
+			return this;
+		}
+	}
+}
diff --git a/src/Nest/DSL/SearchTemplateDescriptor.cs b/src/Nest/DSL/SearchTemplateDescriptor.cs
new file mode 100644
index 00000000000..791edbc1f65
--- /dev/null
+++ b/src/Nest/DSL/SearchTemplateDescriptor.cs
@@ -0,0 +1,170 @@
+using Elasticsearch.Net;
+using Nest.DSL.Descriptors;
+using Nest.Resolvers.Converters;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
+
+namespace Nest
+{
+	internal static class SearchTemplatePathInfo
+	{
+		public static void Update(ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
+		}
+
+		/// <summary>
+		/// Based on the type information present in this descriptor create method that takes
+		/// the returned _source and hit and returns the ClrType it should deserialize too.
+		/// This is so that Documents[A] can contain actual instances of subclasses B, C as well.
+		/// If you specify types using .Types(typeof(B), typeof(C)) then NEST can automagically
+		/// create a TypeSelector based on the hits _type property.
+		/// </summary>
+		public static void CloseOverAutomagicCovariantResultSelector(ElasticInferrer infer, ISearchTemplateRequest self)
+		{
+			if (infer == null || self == null) return;
+			var returnType = self.ClrType;
+
+			if (returnType == null) return;
+
+			var types = (self.Types ?? Enumerable.Empty<TypeNameMarker>()).Where(t => t.Type != null).ToList();
+			if (self.TypeSelector != null || !types.HasAny(t => t.Type != returnType))
+				return;
+
+			var typeDictionary = types.ToDictionary(infer.TypeName, t => t.Type);
+			self.TypeSelector = (o, h) =>
+			{
+				Type t;
+				return !typeDictionary.TryGetValue(h.Type, out t) ? returnType : t;
+			};
+		}
+	}
+
+	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
+	public interface ISearchTemplateRequest 
+		: IQueryPath<SearchTemplateRequestParameters>
+	{
+		[JsonProperty("params")]
+		IDictionary<string, object> Params { get; set; }
+
+		Type ClrType { get; }
+
+		[JsonProperty(PropertyName = "template")]
+		string Template { get; set; }
+
+		[JsonProperty("file")]
+		string File { get; set; }
+
+		[JsonProperty("id")]
+		string Id { get; set; }
+
+		Func<dynamic, Hit<dynamic>, Type> TypeSelector { get; set; }
+	}
+
+	public interface ISearchTemplateRequest<T> : ISearchTemplateRequest { }
+
+	public partial class SearchTemplateRequest 
+		: QueryPathBase<SearchTemplateRequestParameters>, ISearchTemplateRequest
+	{
+		public string Template { get; set; }
+		public string File { get; set; }
+		public string Id { get; set; }
+		public IDictionary<string, object> Params { get; set; }
+		private Type _clrType { get; set; }
+		Type ISearchTemplateRequest.ClrType { get { return _clrType; } }
+		public Func<dynamic, Hit<dynamic>, Type> TypeSelector { get; set; }
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			SearchTemplatePathInfo.Update(pathInfo);
+		}
+	}
+	
+	public partial class SearchTemplateRequest<T> 
+		: QueryPathBase<SearchTemplateRequestParameters, T>, ISearchTemplateRequest
+		where T : class
+	{
+		public string Template { get; set; }
+		public string File { get; set; }
+		public string Id { get; set; }
+		public IDictionary<string, object> Params { get; set; }
+		public Type ClrType { get { return typeof(T); } }
+		public Func<dynamic, Hit<dynamic>, Type> TypeSelector { get; set; }
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			SearchTemplatePathInfo.Update(pathInfo);
+		}
+	}
+
+	public partial class SearchTemplateDescriptor<T> 
+		: QueryPathDescriptorBase<SearchTemplateDescriptor<T>, SearchTemplateRequestParameters, T>, ISearchTemplateRequest<T>
+		where T : class
+	{
+		ISearchTemplateRequest<T> Self { get { return this; } }
+
+		Type ISearchTemplateRequest.ClrType { get { return typeof(T); } }
+
+		/// <summary>
+		/// Whether conditionless queries are allowed or not
+		/// </summary>
+		internal bool _Strict { get; set; }
+
+		string ISearchTemplateRequest.Template { get; set; }
+
+		string ISearchTemplateRequest.File { get; set; }
+
+		string ISearchTemplateRequest.Id { get; set; }
+
+		IDictionary<string, object> ISearchTemplateRequest.Params { get; set; }
+
+		Func<dynamic, Hit<dynamic>, Type> ISearchTemplateRequest.TypeSelector { get; set; }
+
+		public SearchTemplateDescriptor<T> Template(string template)
+		{
+			this.Self.Template = template;
+			return this;
+		}
+
+		public SearchTemplateDescriptor<T> File(string file)
+		{
+			this.Self.File = file;
+			return this;
+		}
+
+		public SearchTemplateDescriptor<T> Id(string id)
+		{
+			this.Self.Id = id;
+			return this;
+		}
+
+		public SearchTemplateDescriptor<T> Params(Dictionary<string, object> paramDictionary)
+		{
+			paramDictionary.ThrowIfNull("paramDictionary");
+			this.Self.Params = paramDictionary;
+			return this;
+		}
+
+		public SearchTemplateDescriptor<T> Params(Func<FluentDictionary<string, object>, FluentDictionary<string, object>> paramDictionary)
+		{
+			paramDictionary.ThrowIfNull("paramDictionary");
+			this.Self.Params = paramDictionary(new FluentDictionary<string, object>());
+			return this;
+		}
+
+		public SearchTemplateDescriptor<T> ConcreteTypeSelector(Func<dynamic, Hit<dynamic>, Type> typeSelector)
+		{
+			Self.TypeSelector = typeSelector;
+			return this;
+		}
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			SearchTemplatePathInfo.Update(pathInfo);
+		}
+	}
+}
diff --git a/src/Nest/DSL/Termplates/CreateWarmerDescriptor.cs b/src/Nest/DSL/Warmers/CreateWarmerDescriptor.cs
similarity index 100%
rename from src/Nest/DSL/Termplates/CreateWarmerDescriptor.cs
rename to src/Nest/DSL/Warmers/CreateWarmerDescriptor.cs
diff --git a/src/Nest/DSL/_Descriptors.generated.cs b/src/Nest/DSL/_Descriptors.generated.cs
index 6d38d281adf..8faa5078a5e 100644
--- a/src/Nest/DSL/_Descriptors.generated.cs
+++ b/src/Nest/DSL/_Descriptors.generated.cs
@@ -1514,6 +1514,38 @@ public DeleteByQueryDescriptor<T> Timeout(string timeout)
 		}
 		
 	
+	}
+	
+	
+	///<summary>descriptor for DeleteScript
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+	///</pre>
+	///</summary>
+	public partial class DeleteScriptDescriptor  : BaseRequest<DeleteScriptRequestParameters>
+	{
+		
+	
+		
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<DeleteScriptRequestParameters> pathInfo)
+		{
+			throw new NotImplementedException();
+		}
+		
+	
+	}
+	
+	
+	///<summary>descriptor for DeleteTemplate
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+	///</pre>
+	///</summary>
+	public partial class DeleteTemplateDescriptor 
+	{
+		
+	
+	
 	}
 	
 	
@@ -1888,6 +1920,25 @@ public GetDescriptor<T> VersionType(VersionType version_type)
 	}
 	
 	
+	///<summary>descriptor for GetScript
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+	///</pre>
+	///</summary>
+	public partial class GetScriptDescriptor  : BaseRequest<GetScriptRequestParameters>
+	{
+		
+	
+		
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<GetScriptRequestParameters> pathInfo)
+		{
+			throw new NotImplementedException();
+		}
+		
+	
+	}
+	
+	
 	///<summary>descriptor for GetSource
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
@@ -2009,6 +2060,19 @@ public SourceDescriptor<T> VersionType(VersionType version_type)
 		}
 		
 	
+	}
+	
+	
+	///<summary>descriptor for GetTemplate
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+	///</pre>
+	///</summary>
+	public partial class GetTemplateDescriptor 
+	{
+		
+	
+	
 	}
 	
 	
@@ -2494,35 +2558,6 @@ public DeleteMappingDescriptor<T> MasterTimeout(string master_timeout)
 	}
 	
 	
-	///<summary>descriptor for IndicesDeleteTemplateForAll
-	///<pre>
-	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
-	///</pre>
-	///</summary>
-	public partial class DeleteTemplateDescriptor 
-	{
-		
-	
-
-		///<summary>Explicit operation timeout</summary>
-		public DeleteTemplateDescriptor Timeout(string timeout)
-		{
-			this.Request.RequestParameters.Timeout(timeout);
-			return this;
-		}
-		
-
-		///<summary>Specify timeout for connection to master</summary>
-		public DeleteTemplateDescriptor MasterTimeout(string master_timeout)
-		{
-			this.Request.RequestParameters.MasterTimeout(master_timeout);
-			return this;
-		}
-		
-	
-	}
-	
-	
 	///<summary>descriptor for IndicesDeleteWarmer
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
@@ -2978,35 +3013,6 @@ public GetIndexSettingsDescriptor Local(bool local = true)
 	}
 	
 	
-	///<summary>descriptor for IndicesGetTemplateForAll
-	///<pre>
-	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
-	///</pre>
-	///</summary>
-	public partial class GetTemplateDescriptor 
-	{
-		
-	
-
-		///<summary>Return settings in flat format (default: false)</summary>
-		public GetTemplateDescriptor FlatSettings(bool flat_settings = true)
-		{
-			this.Request.RequestParameters.FlatSettings(flat_settings);
-			return this;
-		}
-		
-
-		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public GetTemplateDescriptor Local(bool local = true)
-		{
-			this.Request.RequestParameters.Local(local);
-			return this;
-		}
-		
-	
-	}
-	
-	
 	///<summary>descriptor for IndicesGetWarmerForAll
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
@@ -3349,6 +3355,14 @@ public partial class PutTemplateDescriptor
 		
 	
 
+		///<summary>Whether the index template should only be added if new or can also replace an existing one</summary>
+		public PutTemplateDescriptor Create(bool create = true)
+		{
+			this.Request.RequestParameters.Create(create);
+			return this;
+		}
+		
+
 		///<summary>Explicit operation timeout</summary>
 		public PutTemplateDescriptor Timeout(string timeout)
 		{
@@ -3638,7 +3652,7 @@ public IndicesStatsDescriptor Fields<T>(params Expression<Func<T, object>>[] typ
 			
 
 		///<summary>A comma-separated list of search groups for `search` index metric</summary>
-		public IndicesStatsDescriptor Groups(bool groups = true)
+		public IndicesStatsDescriptor Groups(params string[] groups)
 		{
 			this.Request.RequestParameters.Groups(groups);
 			return this;
@@ -4604,6 +4618,25 @@ public partial class PingDescriptor
 		
 	
 	
+	}
+	
+	
+	///<summary>descriptor for PutScript
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+	///</pre>
+	///</summary>
+	public partial class PutScriptDescriptor  : BaseRequest<PutScriptRequestParameters>
+	{
+		
+	
+		
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<PutScriptRequestParameters> pathInfo)
+		{
+			throw new NotImplementedException();
+		}
+		
+	
 	}
 	
 	
@@ -4858,13 +4891,13 @@ protected override void UpdatePathInfo(IConnectionSettingsValues settings, Elast
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html
 	///</pre>
 	///</summary>
-	public partial class SearchTemplateDescriptor  : BaseRequest<SearchTemplateRequestParameters>
+	public partial class SearchTemplateDescriptor<T> 
 	{
 		
 	
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public SearchTemplateDescriptor IgnoreUnavailable(bool ignore_unavailable = true)
+		public SearchTemplateDescriptor<T> IgnoreUnavailable(bool ignore_unavailable = true)
 		{
 			this.Request.RequestParameters.IgnoreUnavailable(ignore_unavailable);
 			return this;
@@ -4872,7 +4905,7 @@ public SearchTemplateDescriptor IgnoreUnavailable(bool ignore_unavailable = true
 		
 
 		///<summary>Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)</summary>
-		public SearchTemplateDescriptor AllowNoIndices(bool allow_no_indices = true)
+		public SearchTemplateDescriptor<T> AllowNoIndices(bool allow_no_indices = true)
 		{
 			this.Request.RequestParameters.AllowNoIndices(allow_no_indices);
 			return this;
@@ -4880,7 +4913,7 @@ public SearchTemplateDescriptor AllowNoIndices(bool allow_no_indices = true)
 		
 
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public SearchTemplateDescriptor ExpandWildcards(ExpandWildcards expand_wildcards)
+		public SearchTemplateDescriptor<T> ExpandWildcards(ExpandWildcards expand_wildcards)
 		{
 			this.Request.RequestParameters.ExpandWildcards(expand_wildcards);
 			return this;
@@ -4888,7 +4921,7 @@ public SearchTemplateDescriptor ExpandWildcards(ExpandWildcards expand_wildcards
 		
 
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public SearchTemplateDescriptor Preference(string preference)
+		public SearchTemplateDescriptor<T> Preference(string preference)
 		{
 			this.Request.RequestParameters.Preference(preference);
 			return this;
@@ -4896,7 +4929,7 @@ public SearchTemplateDescriptor Preference(string preference)
 		
 
 		///<summary>A comma-separated list of specific routing values</summary>
-		public SearchTemplateDescriptor Routing(params string[] routing)
+		public SearchTemplateDescriptor<T> Routing(params string[] routing)
 		{
 			this.Request.RequestParameters.Routing(routing);
 			return this;
@@ -4904,7 +4937,7 @@ public SearchTemplateDescriptor Routing(params string[] routing)
 		
 
 		///<summary>Specify how long a consistent view of the index should be maintained for scrolled search</summary>
-		public SearchTemplateDescriptor Scroll(string scroll)
+		public SearchTemplateDescriptor<T> Scroll(string scroll)
 		{
 			this.Request.RequestParameters.Scroll(scroll);
 			return this;
@@ -4912,18 +4945,12 @@ public SearchTemplateDescriptor Scroll(string scroll)
 		
 
 		///<summary>Search operation type</summary>
-		public SearchTemplateDescriptor SearchType(SearchType search_type)
+		public SearchTemplateDescriptor<T> SearchType(SearchType search_type)
 		{
 			this.Request.RequestParameters.SearchType(search_type);
 			return this;
 		}
 		
-		
-		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
-		{
-			throw new NotImplementedException();
-		}
-		
 	
 	}
 	
diff --git a/src/Nest/DSL/_Requests.generated.cs b/src/Nest/DSL/_Requests.generated.cs
index bafcba1be34..41eb2a224d2 100644
--- a/src/Nest/DSL/_Requests.generated.cs
+++ b/src/Nest/DSL/_Requests.generated.cs
@@ -1424,6 +1424,32 @@ public string Timeout
 	}
 	
 		
+	///<summary>Request parameters for DeleteScript
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+	///</pre>
+	///</summary>
+	public partial class DeleteScriptRequest  : BasePathRequest<DeleteScriptRequestParameters>
+			{
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<DeleteScriptRequestParameters> pathInfo)
+		{
+			throw new NotImplementedException();
+		}
+
+	}
+	
+		
+	///<summary>Request parameters for DeleteTemplate
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+	///</pre>
+	///</summary>
+	public partial class DeleteTemplateRequest 
+			{
+	}
+	
+		
 	///<summary>Request parameters for Exists
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
@@ -1720,6 +1746,22 @@ public VersionType VersionType
 	}
 	
 		
+	///<summary>Request parameters for GetScript
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+	///</pre>
+	///</summary>
+	public partial class GetScriptRequest  : BasePathRequest<GetScriptRequestParameters>
+			{
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<GetScriptRequestParameters> pathInfo)
+		{
+			throw new NotImplementedException();
+		}
+
+	}
+	
+		
 	///<summary>Request parameters for GetSource
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
@@ -1819,6 +1861,16 @@ public VersionType VersionType
 	}
 	
 		
+	///<summary>Request parameters for GetTemplate
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/search-template.html
+	///</pre>
+	///</summary>
+	public partial class GetTemplateRequest 
+			{
+	}
+	
+		
 	///<summary>Request parameters for Index
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html
@@ -2257,32 +2309,6 @@ public string MasterTimeout
 	}
 	
 		
-	///<summary>Request parameters for IndicesDeleteTemplateForAll
-	///<pre>
-	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
-	///</pre>
-	///</summary>
-	public partial class DeleteTemplateRequest 
-			{
-		
-		///<summary>Explicit operation timeout</summary>
-		public string Timeout 
-		{ 
-			get { return this.Request.RequestParameters.GetQueryStringValue<string>("timeout"); } 
-			set { this.Request.RequestParameters.AddQueryString("timeout", value); }
-		}
-		
-		
-		///<summary>Specify timeout for connection to master</summary>
-		public string MasterTimeout 
-		{ 
-			get { return this.Request.RequestParameters.GetQueryStringValue<string>("master_timeout"); } 
-			set { this.Request.RequestParameters.AddQueryString("master_timeout", value); }
-		}
-		
-	}
-	
-		
 	///<summary>Request parameters for IndicesDeleteWarmer
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
@@ -2705,32 +2731,6 @@ public bool Local
 	}
 	
 		
-	///<summary>Request parameters for IndicesGetTemplateForAll
-	///<pre>
-	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
-	///</pre>
-	///</summary>
-	public partial class GetTemplateRequest 
-			{
-		
-		///<summary>Return settings in flat format (default: false)</summary>
-		public bool FlatSettings 
-		{ 
-			get { return this.Request.RequestParameters.GetQueryStringValue<bool>("flat_settings"); } 
-			set { this.Request.RequestParameters.AddQueryString("flat_settings", value); }
-		}
-		
-		
-		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public bool Local 
-		{ 
-			get { return this.Request.RequestParameters.GetQueryStringValue<bool>("local"); } 
-			set { this.Request.RequestParameters.AddQueryString("local", value); }
-		}
-		
-	}
-	
-		
 	///<summary>Request parameters for IndicesGetWarmerForAll
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
@@ -3053,6 +3053,14 @@ public bool FlatSettings
 	public partial class PutTemplateRequest 
 			{
 		
+		///<summary>Whether the index template should only be added if new or can also replace an existing one</summary>
+		public bool Create 
+		{ 
+			get { return this.Request.RequestParameters.GetQueryStringValue<bool>("create"); } 
+			set { this.Request.RequestParameters.AddQueryString("create", value); }
+		}
+		
+		
 		///<summary>Explicit operation timeout</summary>
 		public string Timeout 
 		{ 
@@ -3294,9 +3302,9 @@ public IList<PropertyPathMarker> Fields
 		
 		
 		///<summary>A comma-separated list of search groups for `search` index metric</summary>
-		public bool Groups 
+		public  string[] Groups 
 		{ 
-			get { return this.Request.RequestParameters.GetQueryStringValue<bool>("groups"); } 
+			get { return this.Request.RequestParameters.GetQueryStringValue< string[]>("groups"); } 
 			set { this.Request.RequestParameters.AddQueryString("groups", value); }
 		}
 		
@@ -4126,6 +4134,22 @@ public partial class PingRequest
 	}
 	
 		
+	///<summary>Request parameters for PutScript
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/modules-scripting.html
+	///</pre>
+	///</summary>
+	public partial class PutScriptRequest  : BasePathRequest<PutScriptRequestParameters>
+			{
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<PutScriptRequestParameters> pathInfo)
+		{
+			throw new NotImplementedException();
+		}
+
+	}
+	
+		
 	///<summary>Request parameters for ScrollGet
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
@@ -4359,7 +4383,7 @@ protected override void UpdatePathInfo(IConnectionSettingsValues settings, Elast
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html
 	///</pre>
 	///</summary>
-	public partial class SearchTemplateRequest  : BasePathRequest<SearchTemplateRequestParameters>
+	public partial class SearchTemplateRequest<T> 
 			{
 		
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -4417,12 +4441,6 @@ public SearchType SearchType
 			set { this.Request.RequestParameters.AddQueryString("search_type", value); }
 		}
 		
-
-		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
-		{
-			throw new NotImplementedException();
-		}
-
 	}
 	
 		
@@ -6067,6 +6085,72 @@ public string SuggestText
 	}
 	
 		
+	///<summary>Request parameters for SearchTemplateGet
+	///<pre>
+	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-template.html
+	///</pre>
+	///</summary>
+	public partial class SearchTemplateRequest 
+			{
+		
+		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
+		public bool IgnoreUnavailable 
+		{ 
+			get { return this.Request.RequestParameters.GetQueryStringValue<bool>("ignore_unavailable"); } 
+			set { this.Request.RequestParameters.AddQueryString("ignore_unavailable", value); }
+		}
+		
+		
+		///<summary>Whether to ignore if a wildcard indices expression resolves into no concrete indices. (This includes `_all` string or when no indices have been specified)</summary>
+		public bool AllowNoIndices 
+		{ 
+			get { return this.Request.RequestParameters.GetQueryStringValue<bool>("allow_no_indices"); } 
+			set { this.Request.RequestParameters.AddQueryString("allow_no_indices", value); }
+		}
+		
+		
+		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
+		public ExpandWildcards ExpandWildcards 
+		{ 
+			get { return this.Request.RequestParameters.GetQueryStringValue<ExpandWildcards>("expand_wildcards"); } 
+			set { this.Request.RequestParameters.AddQueryString("expand_wildcards", value); }
+		}
+		
+		
+		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
+		public string Preference 
+		{ 
+			get { return this.Request.RequestParameters.GetQueryStringValue<string>("preference"); } 
+			set { this.Request.RequestParameters.AddQueryString("preference", value); }
+		}
+		
+		
+		///<summary>A comma-separated list of specific routing values</summary>
+		public  string[] Routing 
+		{ 
+			get { return this.Request.RequestParameters.GetQueryStringValue< string[]>("routing"); } 
+			set { this.Request.RequestParameters.AddQueryString("routing", value); }
+		}
+		
+		
+		///<summary>Specify how long a consistent view of the index should be maintained for scrolled search</summary>
+		public string Scroll 
+		{ 
+			get { return this.Request.RequestParameters.GetQueryStringValue<string>("scroll"); } 
+			set { this.Request.RequestParameters.AddQueryString("scroll", value); }
+		}
+		
+		
+		///<summary>Search operation type</summary>
+		public SearchType SearchType 
+		{ 
+			get { return this.Request.RequestParameters.GetQueryStringValue<SearchType>("search_type"); } 
+			set { this.Request.RequestParameters.AddQueryString("search_type", value); }
+		}
+		
+	}
+	
+		
 	///<summary>Request parameters for TermvectorGet
 	///<pre>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html
diff --git a/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs b/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs
index 476a00632c1..0f011f6dfbc 100644
--- a/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs
+++ b/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs
@@ -25,6 +25,8 @@ public class ElasticsearchPathInfo<TParameters> : IElasticsearchPathInfo
 		public string Metric { get; set; }
 		public string IndexMetric { get; set; }
 
+		public string Lang { get; set; }
+
 		public ElasticsearchPathInfo()
 		{
 			this.RequestParameters = new TParameters();
diff --git a/src/Nest/Domain/Responses/DeleteSearchTemplateResponse.cs b/src/Nest/Domain/Responses/DeleteSearchTemplateResponse.cs
new file mode 100644
index 00000000000..c7210765672
--- /dev/null
+++ b/src/Nest/Domain/Responses/DeleteSearchTemplateResponse.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	public interface IDeleteSearchTemplateResponse : IResponse
+	{
+	}
+
+	public class DeleteSearchTemplateResponse : BaseResponse, IDeleteSearchTemplateResponse
+	{
+	}
+}
diff --git a/src/Nest/Domain/Responses/GetSearchTemplateResponse.cs b/src/Nest/Domain/Responses/GetSearchTemplateResponse.cs
new file mode 100644
index 00000000000..a0cbd19b29c
--- /dev/null
+++ b/src/Nest/Domain/Responses/GetSearchTemplateResponse.cs
@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	public interface IGetSearchTemplateResponse : IResponse
+	{
+		string Template { get; set; }
+	}
+
+	[JsonObject]
+	public class GetSearchTemplateResponse : BaseResponse, IGetSearchTemplateResponse
+	{
+		[JsonProperty("template")]
+		public string Template { get; set; }
+	}
+}
diff --git a/src/Nest/Domain/Responses/PutSearchTemplateResponse.cs b/src/Nest/Domain/Responses/PutSearchTemplateResponse.cs
new file mode 100644
index 00000000000..cc474c198a1
--- /dev/null
+++ b/src/Nest/Domain/Responses/PutSearchTemplateResponse.cs
@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	public interface IPutSearchTemplateResponse : IResponse
+	{
+
+	}
+
+	public class PutSearchTemplateResponse : BaseResponse, IPutSearchTemplateResponse
+	{
+	}
+}
diff --git a/src/Nest/ElasticClient-SearchTemplate.cs b/src/Nest/ElasticClient-SearchTemplate.cs
new file mode 100644
index 00000000000..aa10f70276b
--- /dev/null
+++ b/src/Nest/ElasticClient-SearchTemplate.cs
@@ -0,0 +1,237 @@
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Nest
+{
+	public partial class ElasticClient
+	{
+		public ISearchResponse<T> SearchTemplate<T>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector) where T : class
+		{
+			return this.SearchTemplate<T, T>(selector);
+		}
+
+		public ISearchResponse<TResult> SearchTemplate<T, TResult>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector)
+			where T : class
+			where TResult : class
+		{
+			selector.ThrowIfNull("searchSelector");
+			var descriptor = selector(new SearchTemplateDescriptor<T>());
+
+			IPathInfo<SearchTemplateRequestParameters> p = descriptor;
+			var pathInfo = p
+				.ToPathInfo(_connectionSettings)
+				.DeserializationState(this.CreateSearchDeserializer<T, TResult>(descriptor));
+
+			var status = this.RawDispatch.SearchTemplateDispatch<SearchResponse<TResult>>(pathInfo, descriptor);
+			return status.Success ? status.Response : CreateInvalidInstance<SearchResponse<TResult>>(status);
+		}
+
+		public ISearchResponse<T> SearchTemplate<T>(ISearchTemplateRequest request) where T : class
+		{
+			return this.SearchTemplate<T, T>(request);
+		}
+
+		public ISearchResponse<TResult> SearchTemplate<T, TResult>(ISearchTemplateRequest request)
+			where T : class
+			where TResult : class
+		{
+			var pathInfo = request
+				.ToPathInfo(_connectionSettings)
+				.DeserializationState(this.CreateSearchDeserializer<T, TResult>(request));
+
+			var status = this.RawDispatch.SearchTemplateDispatch<SearchResponse<TResult>>(pathInfo, request);
+			return status.Success ? status.Response : CreateInvalidInstance<SearchResponse<TResult>>(status);
+		}
+
+		public Task<ISearchResponse<T>> SearchTemplateAsync<T>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector) where T : class
+		{
+			return this.SearchTemplateAsync<T, T>(selector);
+		}
+
+		public Task<ISearchResponse<TResult>> SearchTemplateAsync<T, TResult>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector)
+			where T : class
+			where TResult : class
+		{
+			selector.ThrowIfNull("selector");
+			var descriptor = selector(new SearchTemplateDescriptor<T>());
+
+			IPathInfo<SearchTemplateRequestParameters> p = descriptor;
+			var pathInfo = p
+				.ToPathInfo(_connectionSettings)
+				.DeserializationState(CreateSearchDeserializer<T, TResult>(descriptor));
+
+			return this.RawDispatch.SearchTemplateDispatchAsync<SearchResponse<TResult>>(pathInfo, descriptor)
+				.ContinueWith<ISearchResponse<TResult>>(t =>
+				{
+					if (t.IsFaulted)
+						throw t.Exception.Flatten().InnerException;
+
+					return t.Result.Success
+						? t.Result.Response
+						: CreateInvalidInstance<SearchResponse<TResult>>(t.Result);
+				});
+		}
+
+		public Task<ISearchResponse<T>> SearchTemplateAsync<T>(ISearchTemplateRequest request) where T : class
+		{
+			return this.SearchTemplateAsync<T, T>(request);
+		}
+
+		public Task<ISearchResponse<TResult>> SearchTemplateAsync<T, TResult>(ISearchTemplateRequest request)
+			where T : class
+			where TResult : class
+		{
+			var pathInfo = request
+				.ToPathInfo(_connectionSettings)
+				.DeserializationState(this.CreateSearchDeserializer<T, TResult>(request));
+
+			return this.RawDispatch.SearchTemplateDispatchAsync<SearchResponse<TResult>>(pathInfo, request)
+				.ContinueWith<ISearchResponse<TResult>>(t =>
+				{
+					if (t.IsFaulted)
+						throw t.Exception.Flatten().InnerException;
+
+					return t.Result.Success
+						? t.Result.Response
+						: CreateInvalidInstance<SearchResponse<TResult>>(t.Result);
+				});
+		}
+
+		public IGetSearchTemplateResponse GetSearchTemplate(string name, Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector = null)
+		{
+			selector = selector ?? (s => s);
+			return this.Dispatch<GetSearchTemplateDescriptor, GetTemplateRequestParameters, GetSearchTemplateResponse>(
+				d => selector(d.Name(name)),
+				(p, d) => this.RawDispatch.GetTemplateDispatch<GetSearchTemplateResponse>(p, d)
+			);
+		}
+
+		public IGetSearchTemplateResponse GetSearchTemplate(IGetSearchTemplateRequest request)
+		{
+			return this.Dispatch<IGetSearchTemplateRequest, GetTemplateRequestParameters, GetSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.GetTemplateDispatch<GetSearchTemplateResponse>(p, d)
+			);
+		}
+
+		public Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(string name, Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector = null)
+		{
+			selector = selector ?? (s => s);
+			return this.DispatchAsync<GetSearchTemplateDescriptor, GetTemplateRequestParameters, GetSearchTemplateResponse, IGetSearchTemplateResponse>(
+				d => selector(d.Name(name)),
+				(p, d) => this.RawDispatch.GetTemplateDispatchAsync<GetSearchTemplateResponse>(p, d)
+			);
+		}
+
+		public Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(IGetSearchTemplateRequest request)
+		{
+			return this.DispatchAsync<IGetSearchTemplateRequest, GetTemplateRequestParameters, GetSearchTemplateResponse, IGetSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.GetTemplateDispatchAsync<GetSearchTemplateResponse>(p, d)
+			);
+		}
+
+		public IPutSearchTemplateResponse PutSearchTemplate(string name, Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector = null)
+		{
+			selector = selector ?? (s => s);
+			return this.Dispatch<PutSearchTemplateDescriptor, PutTemplateRequestParameters, PutSearchTemplateResponse>(
+				d => selector(d.Name(name)),
+				(p, d) => this.RawDispatch.PutTemplateDispatch<PutSearchTemplateResponse>(p, d)
+			);
+		}
+
+		public IPutSearchTemplateResponse PutSearchTemplate(IPutSearchTemplateRequest request)
+		{
+			return this.Dispatch<IPutSearchTemplateRequest, PutTemplateRequestParameters, PutSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.PutTemplateDispatch<PutSearchTemplateResponse>(p, d)
+			);
+		}
+
+		public Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(string name, Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector = null)
+		{
+			selector = selector ?? (s => s);
+			return this.DispatchAsync<PutSearchTemplateDescriptor, PutTemplateRequestParameters, PutSearchTemplateResponse, IPutSearchTemplateResponse>(
+				d => selector(d.Name(name)),
+				(p, d) => this.RawDispatch.PutTemplateDispatchAsync<PutSearchTemplateResponse>(p, d)
+			);
+		}
+
+		public Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(IPutSearchTemplateRequest request)
+		{
+			return this.DispatchAsync<IPutSearchTemplateRequest, PutTemplateRequestParameters, PutSearchTemplateResponse, IPutSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.PutTemplateDispatchAsync<PutSearchTemplateResponse>(p, d)
+			);
+		}
+
+		public IDeleteSearchTemplateResponse DeleteSearchTemplate(string name, Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector = null)
+		{
+			selector = selector ?? (s => s);
+			return this.Dispatch<DeleteSearchTemplateDescriptor, DeleteTemplateRequestParameters, DeleteSearchTemplateResponse>(
+				d => selector(d.Name(name)),
+				(p, d) => this.RawDispatch.DeleteTemplateDispatch<DeleteSearchTemplateResponse>(p)
+			);
+		}
+
+		public IDeleteSearchTemplateResponse DeleteSearchTemplate(IDeleteSearchTemplateRequest request)
+		{
+			return this.Dispatch<IDeleteSearchTemplateRequest, DeleteTemplateRequestParameters, DeleteSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.DeleteTemplateDispatch<DeleteSearchTemplateResponse>(p)
+			);
+		}
+
+		public Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(string name, Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector = null)
+		{
+			selector = selector ?? (s => s);
+			return this.DispatchAsync<DeleteSearchTemplateDescriptor, DeleteTemplateRequestParameters, DeleteSearchTemplateResponse, IDeleteSearchTemplateResponse>(
+				d => selector(d.Name(name)),
+				(p, d) => this.RawDispatch.DeleteTemplateDispatchAsync<DeleteSearchTemplateResponse>(p)
+			);
+		}
+
+		public Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(IDeleteSearchTemplateRequest request)
+		{
+			return this.DispatchAsync<IDeleteSearchTemplateRequest, DeleteTemplateRequestParameters, DeleteSearchTemplateResponse, IDeleteSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.DeleteTemplateDispatchAsync<DeleteSearchTemplateResponse>(p)
+			);
+		}
+
+		private SearchResponse<TResult> FieldsSearchDeserializer<T, TResult>(IElasticsearchResponse response, Stream stream, ISearchTemplateRequest d)
+			where T : class
+			where TResult : class
+		{
+			var converter = this.CreateCovariantSearchSelector<T, TResult>(d);
+			var dict = response.Success
+				? Serializer.DeserializeInternal<SearchResponse<TResult>>(stream, converter)
+				: null;
+			return dict;
+		}
+
+		private Func<IElasticsearchResponse, Stream, SearchResponse<TResult>> CreateSearchDeserializer<T, TResult>(ISearchTemplateRequest request)
+			where T : class
+			where TResult : class
+		{
+
+			Func<IElasticsearchResponse, Stream, SearchResponse<TResult>> responseCreator =
+					(r, s) => this.FieldsSearchDeserializer<T, TResult>(r, s, request);
+			return responseCreator;
+		}
+
+		private JsonConverter CreateCovariantSearchSelector<T, TResult>(ISearchTemplateRequest originalSearchDescriptor)
+			where T : class
+			where TResult : class
+		{
+			SearchTemplatePathInfo.CloseOverAutomagicCovariantResultSelector(this.Infer, originalSearchDescriptor);
+			return originalSearchDescriptor.TypeSelector == null ? null : new ConcreteTypeConverter<TResult>(originalSearchDescriptor.TypeSelector);
+		}
+	}
+}
diff --git a/src/Nest/IElasticClient.cs b/src/Nest/IElasticClient.cs
index c5350819b77..c2b91d09bcf 100644
--- a/src/Nest/IElasticClient.cs
+++ b/src/Nest/IElasticClient.cs
@@ -774,6 +774,84 @@ Task<ISearchResponse<TResult>> SearchAsync<T, TResult>(ISearchRequest request)
 			where T : class
 			where TResult : class;
 
+		/// <summary>
+		/// The /_search/template endpoint allows to use the mustache language to pre render search 
+		/// requests, before they are executed and fill existing templates with template parameters.
+		/// </summary>
+		/// <typeparam name="T">The type used to infer the index and typename as well describe the query strongly typed</typeparam>
+		/// <param name="selector">A descriptor that describes the parameters for the search operation</param>
+		/// <returns></returns>
+		ISearchResponse<T> SearchTemplate<T>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector)
+			where T : class;
+
+		/// <inheritdoc />
+		ISearchResponse<TResult> SearchTemplate<T, TResult>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector)
+			where T : class
+			where TResult : class;
+
+		/// <inheritdoc />
+		ISearchResponse<T> SearchTemplate<T>(ISearchTemplateRequest request)
+			where T : class;
+
+		/// <inheritdoc />
+		ISearchResponse<TResult> SearchTemplate<T, TResult>(ISearchTemplateRequest request)
+			where T : class
+			where TResult : class;
+
+		/// <inheritdoc />
+		Task<ISearchResponse<T>> SearchTemplateAsync<T>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector)
+			where T : class;
+
+		/// <inheritdoc />
+		Task<ISearchResponse<TResult>> SearchTemplateAsync<T, TResult>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector)
+			where T : class
+			where TResult : class;
+
+		/// <inheritdoc />
+		Task<ISearchResponse<T>> SearchTemplateAsync<T>(ISearchTemplateRequest request)
+			where T : class;
+
+		/// <inheritdoc />
+		Task<ISearchResponse<TResult>> SearchTemplateAsync<T, TResult>(ISearchTemplateRequest request)
+			where T : class
+			where TResult : class;
+
+		/// <inheritdoc />
+		IGetSearchTemplateResponse GetSearchTemplate(string name, Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector = null);
+
+		/// <inheritdoc />
+		IGetSearchTemplateResponse GetSearchTemplate(IGetSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(string name, Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector = null);
+
+		/// <inheritdoc />
+		Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(IGetSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		IPutSearchTemplateResponse PutSearchTemplate(string name, Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector = null);
+
+		/// <inheritdoc />
+		IPutSearchTemplateResponse PutSearchTemplate(IPutSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(string name, Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector = null);
+
+		/// <inheritdoc />
+		Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(IPutSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		IDeleteSearchTemplateResponse DeleteSearchTemplate(string name, Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector = null);
+
+		/// <inheritdoc />
+		IDeleteSearchTemplateResponse DeleteSearchTemplate(IDeleteSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(string name, Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector = null);
+
+		/// <inheritdoc />
+		Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(IDeleteSearchTemplateRequest request);
+
 		/// <summary>
 		/// The multi search API allows to execute several search requests within the same API.
 		/// <para> </para>http://www.elasticsearch.org/guide/en/elasticsearch/reference/current/search-multi-search.html
diff --git a/src/Nest/Nest.csproj b/src/Nest/Nest.csproj
index 1bd5fd157d2..6461d010465 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -179,12 +179,15 @@
     <Compile Include="Domain\Cat\CatNodesRecord.cs" />
     <Compile Include="Domain\Responses\ClusterStatsResponse.cs" />
     <Compile Include="Domain\Responses\ClusterPendingTasksResponse.cs" />
+    <Compile Include="Domain\Responses\DeleteSearchTemplateResponse.cs" />
     <Compile Include="Domain\Responses\ExplainResponse.cs" />
     <Compile Include="Domain\Responses\GetFieldMappingResponse.cs" />
     <Compile Include="Domain\Cat\ICatRecord.cs" />
+    <Compile Include="Domain\Responses\GetSearchTemplateResponse.cs" />
     <Compile Include="Domain\Responses\MultiPercolateResponse.cs" />
     <Compile Include="Domain\Responses\NodesHotThreadsResponse.cs" />
     <Compile Include="Domain\Responses\CatResponse.cs" />
+    <Compile Include="Domain\Responses\PutSearchTemplateResponse.cs" />
     <Compile Include="Domain\Stats\ClusterNodesStas.cs" />
     <Compile Include="Domain\Stats\CompletionStats.cs" />
     <Compile Include="Domain\Stats\FieldDataStats.cs" />
@@ -194,6 +197,10 @@
     <Compile Include="Domain\Stats\PercolateStats.cs" />
     <Compile Include="Domain\Stats\PluginStats.cs" />
     <Compile Include="Domain\Stats\SegmentsStats.cs" />
+    <Compile Include="DSL\PutSearchTemplateDescriptor.cs" />
+    <Compile Include="DSL\DeleteSearchTemplateDescriptor.cs" />
+    <Compile Include="DSL\GetSearchTemplateDescriptor.cs" />
+    <Compile Include="DSL\Query\TemplateQueryDescriptor.cs" />
     <Compile Include="DSL\CatIndicesDescriptor.cs" />
     <Compile Include="DSL\CatShardsDescriptor.cs" />
     <Compile Include="DSL\CatThreadPoolDescriptor.cs" />
@@ -209,6 +216,7 @@
     <Compile Include="DSL\ClusterPendingTasksDescriptor.cs" />
     <Compile Include="DSL\ClusterStatsDescriptor.cs" />
     <Compile Include="DSL\CatAliasesDescriptor.cs" />
+    <Compile Include="DSL\SearchTemplateDescriptor.cs" />
     <Compile Include="DSL\TemplateExistsDescriptor.cs" />
     <Compile Include="Domain\Responses\PingResponse.cs" />
     <Compile Include="Domain\Responses\NodesShutdownResponse.cs" />
@@ -299,6 +307,7 @@
     <Compile Include="DSL\Visitor\VisitorScope.cs" />
     <Compile Include="DSL\_Requests.generated.cs" />
     <Compile Include="ElasticClient-Cat.cs" />
+    <Compile Include="ElasticClient-SearchTemplate.cs" />
     <Compile Include="ElasticClient-TemplateExists.cs" />
     <Compile Include="ElasticClient-AliasExists.cs" />
     <Compile Include="ElasticClient-ClusterSettings.cs" />
@@ -542,7 +551,7 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="DSL\Rescore\RescoreDescriptor.cs" />
-    <Compile Include="DSL\Termplates\CreateWarmerDescriptor.cs" />
+    <Compile Include="DSL\Warmers\CreateWarmerDescriptor.cs" />
     <Compile Include="DSL\PutWarmerDescriptor.cs" />
     <Compile Include="DSL\GetWarmerDescriptor.cs" />
     <Compile Include="DSL\Query\MatchPhrasePrefixQueryDescriptor.cs" />
diff --git a/src/Nest/RawDispatch.generated.cs b/src/Nest/RawDispatch.generated.cs
index 27ca7155806..223dfcf9f02 100644
--- a/src/Nest/RawDispatch.generated.cs
+++ b/src/Nest/RawDispatch.generated.cs
@@ -946,6 +946,66 @@ internal Task<ElasticsearchResponse<T>> DeleteByQueryDispatchAsync<T>(Elasticsea
 		}
 		
 		
+		internal ElasticsearchResponse<T> DeleteScriptDispatch<T>(ElasticsearchPathInfo<DeleteScriptRequestParameters> pathInfo )
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.DELETE:
+					//DELETE /_scripts/{lang}/{id}
+					if (!pathInfo.Lang.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
+						return this.Raw.DeleteScript<T>(pathInfo.Lang,pathInfo.Id,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.DeleteScript() into any of the following paths: \r\n - /_scripts/{lang}/{id}");
+		}
+		
+		
+		internal Task<ElasticsearchResponse<T>> DeleteScriptDispatchAsync<T>(ElasticsearchPathInfo<DeleteScriptRequestParameters> pathInfo )
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.DELETE:
+					//DELETE /_scripts/{lang}/{id}
+					if (!pathInfo.Lang.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
+						return this.Raw.DeleteScriptAsync<T>(pathInfo.Lang,pathInfo.Id,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.DeleteScript() into any of the following paths: \r\n - /_scripts/{lang}/{id}");
+		}
+		
+		
+		internal ElasticsearchResponse<T> DeleteTemplateDispatch<T>(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo )
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.DELETE:
+					//DELETE /_search/template/{id}
+					if (!pathInfo.Id.IsNullOrEmpty())
+						return this.Raw.DeleteTemplate<T>(pathInfo.Id,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.DeleteTemplate() into any of the following paths: \r\n - /_search/template/{id}");
+		}
+		
+		
+		internal Task<ElasticsearchResponse<T>> DeleteTemplateDispatchAsync<T>(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo )
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.DELETE:
+					//DELETE /_search/template/{id}
+					if (!pathInfo.Id.IsNullOrEmpty())
+						return this.Raw.DeleteTemplateAsync<T>(pathInfo.Id,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.DeleteTemplate() into any of the following paths: \r\n - /_search/template/{id}");
+		}
+		
+		
 		internal ElasticsearchResponse<T> ExistsDispatch<T>(ElasticsearchPathInfo<DocumentExistsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
@@ -1048,6 +1108,36 @@ internal Task<ElasticsearchResponse<T>> GetDispatchAsync<T>(ElasticsearchPathInf
 		}
 		
 		
+		internal ElasticsearchResponse<T> GetScriptDispatch<T>(ElasticsearchPathInfo<GetScriptRequestParameters> pathInfo )
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.GET:
+					//GET /_scripts/{lang}/{id}
+					if (!pathInfo.Lang.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
+						return this.Raw.GetScript<T>(pathInfo.Lang,pathInfo.Id,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.GetScript() into any of the following paths: \r\n - /_scripts/{lang}/{id}");
+		}
+		
+		
+		internal Task<ElasticsearchResponse<T>> GetScriptDispatchAsync<T>(ElasticsearchPathInfo<GetScriptRequestParameters> pathInfo )
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.GET:
+					//GET /_scripts/{lang}/{id}
+					if (!pathInfo.Lang.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
+						return this.Raw.GetScriptAsync<T>(pathInfo.Lang,pathInfo.Id,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.GetScript() into any of the following paths: \r\n - /_scripts/{lang}/{id}");
+		}
+		
+		
 		internal ElasticsearchResponse<T> GetSourceDispatch<T>(ElasticsearchPathInfo<SourceRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
@@ -1078,6 +1168,36 @@ internal Task<ElasticsearchResponse<T>> GetSourceDispatchAsync<T>(ElasticsearchP
 		}
 		
 		
+		internal ElasticsearchResponse<T> GetTemplateDispatch<T>(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo , object body)
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.GET:
+					//GET /_search/template/{id}
+					if (!pathInfo.Id.IsNullOrEmpty())
+						return this.Raw.GetTemplate<T>(pathInfo.Id,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.GetTemplate() into any of the following paths: \r\n - /_search/template/{id}");
+		}
+		
+		
+		internal Task<ElasticsearchResponse<T>> GetTemplateDispatchAsync<T>(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo , object body)
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.GET:
+					//GET /_search/template/{id}
+					if (!pathInfo.Id.IsNullOrEmpty())
+						return this.Raw.GetTemplateAsync<T>(pathInfo.Id,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.GetTemplate() into any of the following paths: \r\n - /_search/template/{id}");
+		}
+		
+		
 		internal ElasticsearchResponse<T> IndexDispatch<T>(ElasticsearchPathInfo<IndexRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
@@ -3138,6 +3258,90 @@ internal Task<ElasticsearchResponse<T>> PingDispatchAsync<T>(ElasticsearchPathIn
 		}
 		
 		
+		internal ElasticsearchResponse<T> PutScriptDispatch<T>(ElasticsearchPathInfo<PutScriptRequestParameters> pathInfo , object body)
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.PUT:
+					//PUT /_scripts/{lang}/{id}
+					if (!pathInfo.Lang.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
+						return this.Raw.PutScript<T>(pathInfo.Lang,pathInfo.Id,body,u => pathInfo.RequestParameters);
+					break;
+
+				case PathInfoHttpMethod.POST:
+					//POST /_scripts/{lang}/{id}
+					if (!pathInfo.Lang.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
+						return this.Raw.PutScriptPost<T>(pathInfo.Lang,pathInfo.Id,body,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.PutScript() into any of the following paths: \r\n - /_scripts/{lang}/{id}");
+		}
+		
+		
+		internal Task<ElasticsearchResponse<T>> PutScriptDispatchAsync<T>(ElasticsearchPathInfo<PutScriptRequestParameters> pathInfo , object body)
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.PUT:
+					//PUT /_scripts/{lang}/{id}
+					if (!pathInfo.Lang.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
+						return this.Raw.PutScriptAsync<T>(pathInfo.Lang,pathInfo.Id,body,u => pathInfo.RequestParameters);
+					break;
+
+				case PathInfoHttpMethod.POST:
+					//POST /_scripts/{lang}/{id}
+					if (!pathInfo.Lang.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
+						return this.Raw.PutScriptPostAsync<T>(pathInfo.Lang,pathInfo.Id,body,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.PutScript() into any of the following paths: \r\n - /_scripts/{lang}/{id}");
+		}
+		
+		
+		internal ElasticsearchResponse<T> PutTemplateDispatch<T>(ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo , object body)
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.PUT:
+					//PUT /_search/template/{id}
+					if (!pathInfo.Id.IsNullOrEmpty() && body != null)
+						return this.Raw.PutTemplate<T>(pathInfo.Id,body,u => pathInfo.RequestParameters);
+					break;
+
+				case PathInfoHttpMethod.POST:
+					//POST /_search/template/{id}
+					if (!pathInfo.Id.IsNullOrEmpty() && body != null)
+						return this.Raw.PutTemplatePost<T>(pathInfo.Id,body,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.PutTemplate() into any of the following paths: \r\n - /_search/template/{id}");
+		}
+		
+		
+		internal Task<ElasticsearchResponse<T>> PutTemplateDispatchAsync<T>(ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo , object body)
+		{
+			switch(pathInfo.HttpMethod)
+			{
+				case PathInfoHttpMethod.PUT:
+					//PUT /_search/template/{id}
+					if (!pathInfo.Id.IsNullOrEmpty() && body != null)
+						return this.Raw.PutTemplateAsync<T>(pathInfo.Id,body,u => pathInfo.RequestParameters);
+					break;
+
+				case PathInfoHttpMethod.POST:
+					//POST /_search/template/{id}
+					if (!pathInfo.Id.IsNullOrEmpty() && body != null)
+						return this.Raw.PutTemplatePostAsync<T>(pathInfo.Id,body,u => pathInfo.RequestParameters);
+					break;
+
+			}
+			throw new DispatchException("Could not dispatch IElasticClient.PutTemplate() into any of the following paths: \r\n - /_search/template/{id}");
+		}
+		
+		
 		internal ElasticsearchResponse<T> ScrollDispatch<T>(ElasticsearchPathInfo<ScrollRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
diff --git a/src/Tests/Nest.Tests.Integration/Template/TemplateTests.cs b/src/Tests/Nest.Tests.Integration/Indices/IndicesTemplateTests.cs
similarity index 97%
rename from src/Tests/Nest.Tests.Integration/Template/TemplateTests.cs
rename to src/Tests/Nest.Tests.Integration/Indices/IndicesTemplateTests.cs
index dfc74255d44..e55a066a388 100644
--- a/src/Tests/Nest.Tests.Integration/Template/TemplateTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Indices/IndicesTemplateTests.cs
@@ -2,10 +2,10 @@
 using Nest.Tests.MockData.Domain;
 using NUnit.Framework;
 
-namespace Nest.Tests.Integration.Template
+namespace Nest.Tests.Integration.Indices
 {
 	[TestFixture]
-	public class TemplateTests : IntegrationTests
+	public class IndicesTemplateTests : IntegrationTests
 	{
 
 		[Test]
diff --git a/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj b/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
index a953583c60a..340102c482f 100644
--- a/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
+++ b/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
@@ -179,6 +179,7 @@
     <Compile Include="Search\Filter\RangeFilterTests.cs" />
     <Compile Include="Search\Query\BoolQueryResults.cs" />
     <Compile Include="Search\Query\SpanQueryTests.cs" />
+    <Compile Include="Search\Query\TemplateQueryTests.cs" />
     <Compile Include="Search\Query\TermToString.cs" />
     <Compile Include="Core\UpdateTests.cs" />
     <Compile Include="Search\Filter\BoolFilterTests.cs" />
@@ -232,6 +233,7 @@
     <Compile Include="Search\QueryResponseMapperTests.cs" />
     <Compile Include="Search\ScriptFields\ScriptFieldsTest.cs" />
     <Compile Include="Search\Scroll\ScrollTests.cs" />
+    <Compile Include="Search\Template\SearchTemplateTests.cs" />
     <Compile Include="Search\SearchTypeTests\SearchTypeScanTests.cs" />
     <Compile Include="Search\SearchTypeTests\SearchTypeCountTests.cs" />
     <Compile Include="Search\SearchTypeTests\SearchTypeTests.cs" />
@@ -239,7 +241,7 @@
     <Compile Include="Search\VersionTests.cs" />
     <Compile Include="Search\ExplainTests.cs" />
     <Compile Include="Startup\StartupTests.cs" />
-    <Compile Include="Template\TemplateTests.cs" />
+    <Compile Include="Indices\IndicesTemplateTests.cs" />
     <Compile Include="Warmers\IndicesWarmersTests.cs" />
     <Compile Include="Warmers\WarmersTests.cs" />
   </ItemGroup>
diff --git a/src/Tests/Nest.Tests.Integration/Search/Query/TemplateQueryTests.cs b/src/Tests/Nest.Tests.Integration/Search/Query/TemplateQueryTests.cs
new file mode 100644
index 00000000000..efae93b45f3
--- /dev/null
+++ b/src/Tests/Nest.Tests.Integration/Search/Query/TemplateQueryTests.cs
@@ -0,0 +1,35 @@
+
+using FluentAssertions;
+using Nest.Tests.MockData.Domain;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Nest.Tests.Integration.Search.Query
+{
+	[TestFixture]
+	public class TemplateQueryTests : IntegrationTests
+	{
+		[Test]
+		public void TemplateQuery()
+		{
+			var r = this.Client.Search<ElasticsearchProject>(s => s
+				.Query(q => q
+					.Template(t => t
+						.Query("{ \"match\": { \"{{my_field}}\": { \"query\": \"{{my_value}}\" } } }")
+						.Params(p => p
+							.Add("my_field", "name")
+							.Add("my_value", "em-elasticsearch")
+						)
+					)
+				)
+			);
+
+			r.IsValid.Should().BeTrue();
+			r.Hits.Count().Should().BeGreaterThan(0);
+		}
+	}
+}
diff --git a/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs b/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
new file mode 100644
index 00000000000..3e2a26523c5
--- /dev/null
+++ b/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
@@ -0,0 +1,98 @@
+using FluentAssertions;
+using Nest.Tests.MockData.Domain;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Nest.Tests.Integration.Search.Template
+{
+	[TestFixture]
+	public class SearchTemplateTests : IntegrationTests
+	{
+		private string _template = "{\"from\": \"{{my_from}}\",\"size\": \"{{my_size}}\",\"query\": { \"match\": {\"{{my_field}}\": {\"query\": \"{{my_value}}\" }}}}";
+
+		[Test]
+		public void SearchTemplateByQuery()
+		{
+			var result = this.Client.SearchTemplate<ElasticsearchProject>(s => s
+				.Template(_template)
+				.Params(p => p
+					.Add("my_from", 0)
+					.Add("my_size", 5)
+					.Add("my_field", "name")
+					.Add("my_value", "em-elasticsearch")
+				)
+			);
+
+			result.IsValid.Should().BeTrue();
+			result.Hits.Count().Should().BeGreaterThan(0);
+		}
+
+		[Test]
+		public void SearchTemplateByQuery_ObjectInitializer()
+		{
+			var request = new SearchTemplateRequest
+			{
+				Template = _template,
+				Params = new Dictionary<string, object>
+				{
+					{ "my_from", 0 },
+					{ "my_size", 5 },
+					{ "my_field", "name" },
+					{ "my_value", "em-elasticsearch" }
+				}
+			};
+
+			var result = this.Client.SearchTemplate<ElasticsearchProject>(request);
+
+			result.IsValid.Should().BeTrue();
+			result.Hits.Count().Should().BeGreaterThan(0);
+		}
+
+		[Test]
+		public void SearchTemplateById()
+		{
+			var templateName = "myIndexedTemplate";
+
+			var putTemplateResult = this.Client.PutSearchTemplate(templateName, t => t.Template(_template));
+			putTemplateResult.IsValid.Should().BeTrue();
+
+			var result = this.Client.SearchTemplate<ElasticsearchProject>(s => s
+				.Id(templateName)
+				.Params(p => p
+					.Add("my_from", 0)
+					.Add("my_size", 5)
+					.Add("my_field", "name")
+					.Add("my_value", "em-elasticsearch")
+				)
+			);
+
+			result.IsValid.Should().BeTrue();
+			result.Hits.Count().Should().BeGreaterThan(0);
+
+			var deleteTemplateResult = this.Client.DeleteSearchTemplate(templateName);
+			deleteTemplateResult.IsValid.Should().BeTrue();
+		}
+
+		[Test]
+		public void PutGetAndDeleteTemplate()
+		{
+			var templateName = "myIndexedTemplate";
+
+			var putResult = this.Client.PutSearchTemplate(templateName, t => t.Template(_template));
+			putResult.IsValid.Should().BeTrue();
+
+			var getResult = this.Client.GetSearchTemplate(templateName);
+			getResult.IsValid.Should().BeTrue();
+			getResult.Template.ShouldBeEquivalentTo(_template);
+			
+			var deleteResult = this.Client.DeleteSearchTemplate(templateName);
+			deleteResult.IsValid.Should().BeTrue();
+		}
+	}
+}
+
diff --git a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
index 77e9441ad9a..8e647fe5ffc 100644
--- a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
+++ b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
@@ -405,6 +405,7 @@
     <Compile Include="Search\Query\Singles\MultiMatch\MultiMatchJson.cs" />
     <Compile Include="Search\Query\Modes\QueryModesTests.cs" />
     <Compile Include="Search\Query\Singles\SpanMultiTermQueryJson.cs" />
+    <Compile Include="Search\Query\Singles\TemplateQueryJson.cs" />
     <Compile Include="Search\Query\Singles\Term\TermToStringJson.cs" />
     <Compile Include="Search\Rescoring\RescoreTests.cs" />
     <Compile Include="Search\Facets\DateHistogramFacetJson.cs" />
diff --git a/src/Tests/Nest.Tests.Unit/Search/Query/Singles/TemplateQueryJson.cs b/src/Tests/Nest.Tests.Unit/Search/Query/Singles/TemplateQueryJson.cs
new file mode 100644
index 00000000000..a6a4f184502
--- /dev/null
+++ b/src/Tests/Nest.Tests.Unit/Search/Query/Singles/TemplateQueryJson.cs
@@ -0,0 +1,74 @@
+using Nest.Tests.MockData.Domain;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Nest.Tests.Unit.Search.Query.Singles
+{
+	[TestFixture]
+	public class TemplateQueryJson : BaseJsonTests
+	{
+		[Test]
+		public void TemplateQuery()
+		{
+			var s = new SearchDescriptor<ElasticsearchProject>()
+				.From(0)
+				.Size(10)
+				.Query(q => q
+					.Template(t => t
+						.Query("match_{{template}}")
+						.Params(p => p
+							.Add("template", "all")
+						)
+					)
+			);
+
+			var json = TestElasticClient.Serialize(s);
+			var expected = @"{ from: 0, size: 10,
+				  query: {
+					template: {
+					  query: ""match_{{template}}"",
+					  ""params"": {
+						template: ""all""
+					  }
+					}
+				  }
+				}";
+
+			Assert.True(json.JsonEquals(expected), json);
+		}
+
+		[Test]
+		public void TemplateQueryWithEscapeString()
+		{
+			var s = new SearchDescriptor<ElasticsearchProject>()
+				.From(0)
+				.Size(10)
+				.Query(q => q
+					.Template(t => t
+						.Query("\"match_{{template}}\": {}}\"")
+						.Params(p => p
+							.Add("template", "all")
+						)
+					)
+			);
+
+			var json = TestElasticClient.Serialize(s);
+			var expected = @"{ from: 0, size: 10,
+				  query: {
+					template: {
+					  query: ""\""match_{{template}}\"": {}}\"""",
+					  ""params"": {
+						template: ""all""
+					  }
+					}
+				  }
+				}";
+
+			Assert.True(json.JsonEquals(expected), json);
+		}
+	}
+}