From 498eaa8059174a46a43207bb0362d95fadccf3dc Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 2 Sep 2014 15:54:48 +0200
Subject: [PATCH 01/15] added template API syntax spike as a unit tests so
 @gmarz and I can itterate over it together

---
 .../Template/TemplateSpikeTests.cs            | 132 ++++++++++++++++++
 1 file changed, 132 insertions(+)
 create mode 100644 src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs

diff --git a/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs b/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
new file mode 100644
index 00000000000..5553d406db7
--- /dev/null
+++ b/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
@@ -0,0 +1,132 @@
+using System;
+using Elasticsearch.Net;
+using Elasticsearch.Net.Connection;
+using FluentAssertions;
+using Newtonsoft.Json;
+using NUnit.Framework;
+using System.Collections.Generic;
+
+namespace Nest.Tests.Unit.Template
+{
+	[TestFixture]
+	public class TemplateSpikeTests : BaseJsonTests
+	{
+		[Test]
+		public void Print()
+		{
+
+			var search = this._client.Search<object>(s => s
+					.Strict()
+					.Query(q =>
+						Template.If("start",
+							q.Range(r => r
+								.OnField("fieldx")
+								.Greater(Template.Variable("start"))
+								.Lower(Template.Variable("end", "20"))
+							)
+						)
+						&& Template.If("other_var", new TermQuery()
+						{
+							Field = Template.Variable("myfield"),
+							Value = Template.Variable("myval")
+						})
+						&& q.Terms("field", Template.Array("array"))
+					)
+					.Sort(Template.If<object>("sort", sort => sort.Ascending().OnField("{{sort}}")))
+				);
+			Assert.Fail(search.ConnectionStatus.ToString());
+		}
+
+	}
+
+	interface IIfTemplate
+	{
+		object Instance { get; }
+		string Variable { get; }
+	}
+	// Define other methods and classes here
+	public static class Template
+	{
+		[JsonConverter(typeof(IfTemplateConverter))]
+		private class IfSortFieldDescriptor : SortFieldDescriptor<object>, IIfTemplate
+		{
+			private readonly IFieldSort _queryContainer;
+			private readonly string _variable;
+			object IIfTemplate.Instance { get { return _queryContainer; } }
+			string IIfTemplate.Variable { get { return _variable; } }
+			public IfSortFieldDescriptor(string variable, IFieldSort o)
+			{
+				_variable = variable;
+				_queryContainer = o;
+			}
+		}
+
+
+		[JsonConverter(typeof(IfTemplateConverter))]
+		private class IfQueryContainer : QueryContainer, IIfTemplate
+		{
+			private readonly QueryContainer _queryContainer;
+			private readonly string _variable;
+			object IIfTemplate.Instance { get { return _queryContainer; } }
+			string IIfTemplate.Variable { get { return _variable; } }
+			public IfQueryContainer(string variable, QueryContainer o)
+			{
+				_variable = variable;
+				_queryContainer = o;
+			}
+		}
+		public static Func<SortFieldDescriptor<T>, IFieldSort> If<T>(string variable, Func<SortFieldDescriptor<T>, IFieldSort> s)
+		where T : class
+		{
+			return new Func<SortFieldDescriptor<T>, IFieldSort>(inner => new IfSortFieldDescriptor(variable, s(inner)));
+		}
+		public static QueryContainer If(string variable, QueryContainer o)
+		{
+			return new IfQueryContainer(variable, o);
+		}
+
+		public static string Variable(string name, string defaultValue = null)
+		{
+			if (!string.IsNullOrWhiteSpace(defaultValue))
+				return "{{" + name + "}}{{^" + name + "}}" + defaultValue + "{{/" + name + "}}";
+			return "{{" + name + "}}";
+		}
+		public static IEnumerable<string> Array(string name)
+		{
+			return new[] {
+			"{{#"+name+"}",
+			"{{.}}",
+			"{{/" + name + "}"
+			
+		};
+		}
+	}
+
+	public class IfTemplateConverter : JsonConverter
+	{
+		public override bool CanWrite { get { return true; } }
+
+		public override bool CanRead { get { return false; } }
+
+		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+		{
+			var v = value as IIfTemplate;
+			if (v == null) writer.WriteNull();
+
+			writer.WriteRaw("{{#" + v.Variable + "}}");
+			serializer.Serialize(writer, v.Instance);
+			writer.WriteRaw("{{/" + v.Variable + "}}");
+
+		}
+
+		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+		{
+			return null;
+		}
+
+		public override bool CanConvert(Type objectType)
+		{
+			return true;
+		}
+	}
+}

From 19f2145474261f91343ae130cdec2c4b8f28c78f Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Tue, 2 Sep 2014 23:44:03 -0400
Subject: [PATCH 02/15] Refactoring of initial search template implementation

* Mapped to search template endpoint
* Class/method renaming and folder structuring
* Unit tests to demonstrate syntax
---
 src/Nest/DSL/SearchTemplateDescriptor.cs      | 200 ++++++++++++++++++
 .../Template/TemplateSectionQueryContainer.cs |  24 +++
 .../TemplateSectionSortFieldDescriptor.cs     |  23 ++
 .../CreateWarmerDescriptor.cs                 |   0
 src/Nest/DSL/_Descriptors.generated.cs        |  22 +-
 src/Nest/DSL/_Requests.generated.cs           |  74 ++++++-
 src/Nest/Domain/Template/ITemplateSection.cs  |  13 ++
 src/Nest/Domain/Template/TemplateBuilder.cs   |  38 ++++
 src/Nest/ElasticClient-SearchTemplate.cs      |  63 ++++++
 src/Nest/IElasticClient.cs                    |   3 +
 src/Nest/Nest.csproj                          |   9 +-
 .../Converters/TemplateSectionConverter.cs    |  35 +++
 .../Nest.Tests.Unit/Nest.Tests.Unit.csproj    |   4 +
 .../Template/TemplateSpikeTests.cs            | 153 +++++---------
 14 files changed, 544 insertions(+), 117 deletions(-)
 create mode 100644 src/Nest/DSL/SearchTemplateDescriptor.cs
 create mode 100644 src/Nest/DSL/Template/TemplateSectionQueryContainer.cs
 create mode 100644 src/Nest/DSL/Template/TemplateSectionSortFieldDescriptor.cs
 rename src/Nest/DSL/{Termplates => Warmers}/CreateWarmerDescriptor.cs (100%)
 create mode 100644 src/Nest/Domain/Template/ITemplateSection.cs
 create mode 100644 src/Nest/Domain/Template/TemplateBuilder.cs
 create mode 100644 src/Nest/ElasticClient-SearchTemplate.cs
 create mode 100644 src/Nest/Resolvers/Converters/TemplateSectionConverter.cs

diff --git a/src/Nest/DSL/SearchTemplateDescriptor.cs b/src/Nest/DSL/SearchTemplateDescriptor.cs
new file mode 100644
index 00000000000..42567163b8d
--- /dev/null
+++ b/src/Nest/DSL/SearchTemplateDescriptor.cs
@@ -0,0 +1,200 @@
+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 = "sort")]
+		[JsonConverter(typeof(SortCollectionConverter))]
+		IList<KeyValuePair<PropertyPathMarker, ISort>> Sort { get; set; }
+
+		[JsonProperty(PropertyName = "template")]
+		SearchTemplate Template { get; set; }
+
+		Func<dynamic, Hit<dynamic>, Type> TypeSelector { get; set; }
+	}
+
+	public interface ISearchTemplateRequest<T> : ISearchTemplateRequest { }
+
+	public partial class SearchTemplateRequest 
+		: QueryPathBase<SearchTemplateRequestParameters>, ISearchTemplateRequest
+	{
+		public SearchTemplate Template { get; set; }
+		public IDictionary<string, object> Params { get; set; }
+		private Type _clrType { get; set; }
+		Type ISearchTemplateRequest.ClrType { get { return _clrType; } }
+		public IList<KeyValuePair<PropertyPathMarker, ISort>> Sort { get; set; }
+		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 SearchTemplate Template { get; set; }
+		public IDictionary<string, object> Params { get; set; }
+		public Type ClrType { get { return typeof(T); } }
+		public IList<KeyValuePair<PropertyPathMarker, ISort>> Sort { get; set; }
+		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; }
+
+		SearchTemplate ISearchTemplateRequest.Template { get; set; }
+
+		IDictionary<string, object> ISearchTemplateRequest.Params { get; set; }
+
+		IList<KeyValuePair<PropertyPathMarker, ISort>> ISearchTemplateRequest.Sort { get; set; }
+
+		Func<dynamic, Hit<dynamic>, Type> ISearchTemplateRequest.TypeSelector { get; set; }
+
+		public SearchTemplateDescriptor<T> Template(Func<TemplateDescriptor, TemplateDescriptor> templateSelector)
+		{
+			templateSelector.ThrowIfNull("templateSelector");
+			var descriptor = templateSelector(new TemplateDescriptor());
+			this.Self.Template = descriptor.Template;
+			return this;
+		}
+
+		public SearchTemplateDescriptor<T> Params(IDictionary<string, object> parameters)
+		{
+			this.Self.Params = parameters;
+			return this;
+		}
+
+		/// <summary>
+		/// <para>Sort() allows you to fully describe your sort unlike the SortAscending and SortDescending aliases.
+		/// </para>
+		/// </summary>
+		public SearchTemplateDescriptor<T> Sort(Func<SortFieldDescriptor<T>, IFieldSort> sortSelector)
+		{
+			if (Self.Sort == null)
+				Self.Sort = new List<KeyValuePair<PropertyPathMarker, ISort>>();
+
+			sortSelector.ThrowIfNull("sortSelector");
+			var descriptor = sortSelector(new SortFieldDescriptor<T>());
+			Self.Sort.Add(new KeyValuePair<PropertyPathMarker, ISort>(descriptor.Field, descriptor));
+			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);
+		}
+	}
+
+	[JsonObject]
+	public class SearchTemplate
+	{
+		[JsonProperty("file")]
+		public string File { get; set; }
+
+		[JsonProperty("id")]
+		public string Id { get; set; }
+
+		[JsonProperty("query")]
+		public IQueryContainer Query { get; set; }
+	}
+
+	public class TemplateDescriptor
+	{
+		public SearchTemplate Template = new SearchTemplate();
+
+		public TemplateDescriptor File(string file)
+		{
+			Template.File = file;
+			return this;
+		}
+
+		public TemplateDescriptor Id(string id)
+		{
+			Template.Id = id;
+			return this;
+		}
+
+		public TemplateDescriptor Query<T>(Func<QueryDescriptor<T>, QueryContainer> query) where T : class
+		{
+			query.ThrowIfNull("query");
+			var q = new QueryDescriptor<T>();
+			((IQueryContainer)q).IsStrict = true;
+			Template.Query = query(q);
+			return this;
+		}
+	}
+}
diff --git a/src/Nest/DSL/Template/TemplateSectionQueryContainer.cs b/src/Nest/DSL/Template/TemplateSectionQueryContainer.cs
new file mode 100644
index 00000000000..87e017f3c28
--- /dev/null
+++ b/src/Nest/DSL/Template/TemplateSectionQueryContainer.cs
@@ -0,0 +1,24 @@
+using Nest.Resolvers.Converters;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	[JsonConverter(typeof(TemplateSectionConverter))]
+	public class TemplateSectionQueryContainer : QueryContainer, ITemplateSection
+	{
+		private readonly QueryContainer _queryContainer;
+		private readonly string _variable;
+		object ITemplateSection.Instance { get { return _queryContainer; } }
+		string ITemplateSection.Variable { get { return _variable; } }
+
+		public TemplateSectionQueryContainer(string variable, QueryContainer o)
+		{
+			_variable = variable;
+			_queryContainer = o;
+		}
+	}
+}
diff --git a/src/Nest/DSL/Template/TemplateSectionSortFieldDescriptor.cs b/src/Nest/DSL/Template/TemplateSectionSortFieldDescriptor.cs
new file mode 100644
index 00000000000..9c936b0a21c
--- /dev/null
+++ b/src/Nest/DSL/Template/TemplateSectionSortFieldDescriptor.cs
@@ -0,0 +1,23 @@
+using Nest.Resolvers.Converters;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	[JsonConverter(typeof(TemplateSectionConverter))]
+	public class TemplateSectionSortFieldDescriptor : SortFieldDescriptor<object>, ITemplateSection
+	{
+		private readonly IFieldSort _queryContainer;
+		private readonly string _variable;
+		object ITemplateSection.Instance { get { return _queryContainer; } }
+		string ITemplateSection.Variable { get { return _variable; } }
+		public TemplateSectionSortFieldDescriptor(string variable, IFieldSort o)
+		{
+			_variable = variable;
+			_queryContainer = o;
+		}
+	}
+}
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..de4c770f304 100644
--- a/src/Nest/DSL/_Descriptors.generated.cs
+++ b/src/Nest/DSL/_Descriptors.generated.cs
@@ -4858,13 +4858,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 +4872,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 +4880,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 +4888,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 +4896,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 +4904,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 +4912,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..89eb2f87753 100644
--- a/src/Nest/DSL/_Requests.generated.cs
+++ b/src/Nest/DSL/_Requests.generated.cs
@@ -4359,7 +4359,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 +4417,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 +6061,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/Template/ITemplateSection.cs b/src/Nest/Domain/Template/ITemplateSection.cs
new file mode 100644
index 00000000000..bbf69359fd2
--- /dev/null
+++ b/src/Nest/Domain/Template/ITemplateSection.cs
@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	public interface ITemplateSection
+	{
+		object Instance { get; }
+		string Variable { get; }
+	}
+}
diff --git a/src/Nest/Domain/Template/TemplateBuilder.cs b/src/Nest/Domain/Template/TemplateBuilder.cs
new file mode 100644
index 00000000000..acb78966d94
--- /dev/null
+++ b/src/Nest/Domain/Template/TemplateBuilder.cs
@@ -0,0 +1,38 @@
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	public static class TemplateBuilder
+	{
+		public static Func<SortFieldDescriptor<T>, IFieldSort> Section<T>(string variable, Func<SortFieldDescriptor<T>, IFieldSort> s)
+			where T : class
+		{
+			return new Func<SortFieldDescriptor<T>, IFieldSort>(inner => new TemplateSectionSortFieldDescriptor(variable, s(inner)));
+		}
+
+		public static QueryContainer Section(string variable, QueryContainer o)
+		{
+			return new TemplateSectionQueryContainer(variable, o);
+		}
+
+		public static string Variable(string name, string defaultValue = null)
+		{
+			if (!string.IsNullOrWhiteSpace(defaultValue))
+				return "{{" + name + "}}{{^" + name + "}}" + defaultValue + "{{/" + name + "}}";
+			return "{{" + name + "}}";
+		}
+
+		public static IEnumerable<string> Array(string name)
+		{
+			return new[] {
+				"{{#"+name+"}",
+				"{{.}}",
+				"{{/" + name + "}"
+			};
+		}
+	}
+}
diff --git a/src/Nest/ElasticClient-SearchTemplate.cs b/src/Nest/ElasticClient-SearchTemplate.cs
new file mode 100644
index 00000000000..65f1569a009
--- /dev/null
+++ b/src/Nest/ElasticClient-SearchTemplate.cs
@@ -0,0 +1,63 @@
+using Elasticsearch.Net;
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+
+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);
+		}
+
+		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..c201ff0ac6d 100644
--- a/src/Nest/IElasticClient.cs
+++ b/src/Nest/IElasticClient.cs
@@ -774,6 +774,9 @@ Task<ISearchResponse<TResult>> SearchAsync<T, TResult>(ISearchRequest request)
 			where T : class
 			where TResult : class;
 
+		ISearchResponse<T> SearchTemplate<T>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector)
+			where T : class;
+
 		/// <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..aa5384f9efd 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -194,6 +194,10 @@
     <Compile Include="Domain\Stats\PercolateStats.cs" />
     <Compile Include="Domain\Stats\PluginStats.cs" />
     <Compile Include="Domain\Stats\SegmentsStats.cs" />
+    <Compile Include="Domain\Template\ITemplateSection.cs" />
+    <Compile Include="Domain\Template\TemplateBuilder.cs" />
+    <Compile Include="DSL\Template\TemplateSectionQueryContainer.cs" />
+    <Compile Include="DSL\Template\TemplateSectionSortFieldDescriptor.cs" />
     <Compile Include="DSL\CatIndicesDescriptor.cs" />
     <Compile Include="DSL\CatShardsDescriptor.cs" />
     <Compile Include="DSL\CatThreadPoolDescriptor.cs" />
@@ -209,6 +213,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 +304,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 +548,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" />
@@ -891,6 +897,7 @@
     <Compile Include="Resolvers\Converters\DynamicMappingOptionConverter.cs" />
     <Compile Include="Resolvers\Converters\DictionaryKeysAreNotPropertyNamesJsonConverter.cs" />
     <Compile Include="Resolvers\Converters\IndexNameMarkerConverter.cs" />
+    <Compile Include="Resolvers\Converters\TemplateSectionConverter.cs" />
     <Compile Include="Resolvers\Converters\TokenFilterCollectionConverter.cs" />
     <Compile Include="Resolvers\Converters\TokenizerCollectionConverter.cs" />
     <Compile Include="Resolvers\Converters\TypeNameMarkerConverter.cs" />
diff --git a/src/Nest/Resolvers/Converters/TemplateSectionConverter.cs b/src/Nest/Resolvers/Converters/TemplateSectionConverter.cs
new file mode 100644
index 00000000000..2f004ba5cb3
--- /dev/null
+++ b/src/Nest/Resolvers/Converters/TemplateSectionConverter.cs
@@ -0,0 +1,35 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest.Resolvers.Converters
+{
+	public class TemplateSectionConverter : JsonConverter
+	{
+		public override bool CanWrite { get { return true; } }
+
+		public override bool CanRead { get { return false; } }
+
+		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+		{
+			var v = value as ITemplateSection;
+			if (v == null) writer.WriteNull();
+
+			writer.WriteRaw("{{#" + v.Variable + "}}");
+			serializer.Serialize(writer, v.Instance);
+			writer.WriteRaw("{{/" + v.Variable + "}}");
+		}
+
+		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+		{
+			return null;
+		}
+
+		public override bool CanConvert(Type objectType)
+		{
+			return true;
+		}
+	}
+}
diff --git a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
index 77e9441ad9a..aaafb84ca2e 100644
--- a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
+++ b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
@@ -505,6 +505,9 @@
     <Compile Include="Search\Suggest\PhraseSuggestTests.cs" />
     <Compile Include="Search\Suggest\TermSuggestTests.cs" />
     <Compile Include="Settings\UsePrettyResponseTests.cs" />
+    <Compile Include="Template\TemplateSpikeTests.cs">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="TestElasticClient.cs" />
     <Compile Include="Core\Update\UpdateTests.cs" />
   </ItemGroup>
@@ -1246,6 +1249,7 @@
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs b/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
index 5553d406db7..62e7536bf71 100644
--- a/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
+++ b/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
@@ -1,9 +1,11 @@
-using System;
-using Elasticsearch.Net;
+using Elasticsearch.Net;
 using Elasticsearch.Net.Connection;
 using FluentAssertions;
+using Nest;
+using Nest.Tests.MockData.Domain;
 using Newtonsoft.Json;
 using NUnit.Framework;
+using System;
 using System.Collections.Generic;
 
 namespace Nest.Tests.Unit.Template
@@ -15,118 +17,79 @@ public class TemplateSpikeTests : BaseJsonTests
 		public void Print()
 		{
 
-			var search = this._client.Search<object>(s => s
+			var search = this._client.Search<ElasticsearchProject>(s => s
 					.Strict()
 					.Query(q =>
-						Template.If("start",
+						TemplateBuilder.Section("start",
 							q.Range(r => r
 								.OnField("fieldx")
-								.Greater(Template.Variable("start"))
-								.Lower(Template.Variable("end", "20"))
+								.Greater(TemplateBuilder.Variable("start"))
+								.Lower(TemplateBuilder.Variable("end", "20"))
 							)
 						)
-						&& Template.If("other_var", new TermQuery()
+						&& TemplateBuilder.Section("other_var", new TermQuery()
 						{
-							Field = Template.Variable("myfield"),
-							Value = Template.Variable("myval")
+							Field = TemplateBuilder.Variable("myfield"),
+							Value = TemplateBuilder.Variable("myval")
 						})
-						&& q.Terms("field", Template.Array("array"))
+						&& q.Terms("field", TemplateBuilder.Array("array"))
 					)
-					.Sort(Template.If<object>("sort", sort => sort.Ascending().OnField("{{sort}}")))
+					.Sort(TemplateBuilder.Section<ElasticsearchProject>("sort", sort => sort.Ascending().OnField("{{sort}}")))
 				);
-			Assert.Fail(search.ConnectionStatus.ToString());
-		}
-
-	}
-
-	interface IIfTemplate
-	{
-		object Instance { get; }
-		string Variable { get; }
-	}
-	// Define other methods and classes here
-	public static class Template
-	{
-		[JsonConverter(typeof(IfTemplateConverter))]
-		private class IfSortFieldDescriptor : SortFieldDescriptor<object>, IIfTemplate
-		{
-			private readonly IFieldSort _queryContainer;
-			private readonly string _variable;
-			object IIfTemplate.Instance { get { return _queryContainer; } }
-			string IIfTemplate.Variable { get { return _variable; } }
-			public IfSortFieldDescriptor(string variable, IFieldSort o)
-			{
-				_variable = variable;
-				_queryContainer = o;
-			}
-		}
-
-
-		[JsonConverter(typeof(IfTemplateConverter))]
-		private class IfQueryContainer : QueryContainer, IIfTemplate
-		{
-			private readonly QueryContainer _queryContainer;
-			private readonly string _variable;
-			object IIfTemplate.Instance { get { return _queryContainer; } }
-			string IIfTemplate.Variable { get { return _variable; } }
-			public IfQueryContainer(string variable, QueryContainer o)
-			{
-				_variable = variable;
-				_queryContainer = o;
-			}
-		}
-		public static Func<SortFieldDescriptor<T>, IFieldSort> If<T>(string variable, Func<SortFieldDescriptor<T>, IFieldSort> s)
-		where T : class
-		{
-			return new Func<SortFieldDescriptor<T>, IFieldSort>(inner => new IfSortFieldDescriptor(variable, s(inner)));
-		}
-		public static QueryContainer If(string variable, QueryContainer o)
-		{
-			return new IfQueryContainer(variable, o);
-		}
 
-		public static string Variable(string name, string defaultValue = null)
-		{
-			if (!string.IsNullOrWhiteSpace(defaultValue))
-				return "{{" + name + "}}{{^" + name + "}}" + defaultValue + "{{/" + name + "}}";
-			return "{{" + name + "}}";
-		}
-		public static IEnumerable<string> Array(string name)
-		{
-			return new[] {
-			"{{#"+name+"}",
-			"{{.}}",
-			"{{/" + name + "}"
-			
-		};
+			Assert.Fail(search.ConnectionStatus.ToString());
 		}
-	}
-
-	public class IfTemplateConverter : JsonConverter
-	{
-		public override bool CanWrite { get { return true; } }
-
-		public override bool CanRead { get { return false; } }
 
-		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+		[Test]
+		public void SearchTemplateByQuery()
 		{
-			var v = value as IIfTemplate;
-			if (v == null) writer.WriteNull();
-
-			writer.WriteRaw("{{#" + v.Variable + "}}");
-			serializer.Serialize(writer, v.Instance);
-			writer.WriteRaw("{{/" + v.Variable + "}}");
-
+			var search = this._client.SearchTemplate<ElasticsearchProject>(s => s
+				.Template(t => t
+					.Query<object>(q =>
+						TemplateBuilder.Section("start", q.Match(m => m
+								.OnField(TemplateBuilder.Variable("my_field"))
+								.Query(TemplateBuilder.Variable("my_value"))
+							)
+						)
+					)
+				)
+				.Params(new Dictionary<string, object>
+					{
+						{ "my_field", "foo" },
+						{ "my_value", "bar" }
+					}
+				)
+			);
 		}
 
-		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+		[Test]
+		public void SearchTemplateByFile()
 		{
-			return null;
+			var search = this._client.SearchTemplate<ElasticsearchProject>(s => s
+				.Template(t => t
+					.File("myTemplate.mustache")
+				)
+				.Params(new Dictionary<string, object>
+				{
+					{ "my_field", "foo" },
+					{ "my_value", "bar" }
+				})
+			);
 		}
 
-		public override bool CanConvert(Type objectType)
+		[Test]
+		public void SearchTemplateById()
 		{
-			return true;
+			var search = this._client.SearchTemplate<ElasticsearchProject>(s => s
+				.Template(t => t
+					.Id("myTemplateName")
+				)
+				.Params(new Dictionary<string, object>
+				{
+					{ "my_field", "foo" },
+					{ "my_value", "bar" }
+				})
+			);
 		}
 	}
-}
+}
\ No newline at end of file

From bad9044959ebd9cb2e9cb560ef41688f7d2f2aad Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 9 Sep 2014 04:45:13 +0200
Subject: [PATCH 03/15] formatting

---
 .../Nest.Tests.Unit/Template/TemplateSpikeTests.cs   | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs b/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
index 5553d406db7..4077e609c2e 100644
--- a/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
+++ b/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
@@ -75,6 +75,7 @@ public IfQueryContainer(string variable, QueryContainer o)
 				_queryContainer = o;
 			}
 		}
+
 		public static Func<SortFieldDescriptor<T>, IFieldSort> If<T>(string variable, Func<SortFieldDescriptor<T>, IFieldSort> s)
 		where T : class
 		{
@@ -94,11 +95,10 @@ public static string Variable(string name, string defaultValue = null)
 		public static IEnumerable<string> Array(string name)
 		{
 			return new[] {
-			"{{#"+name+"}",
-			"{{.}}",
-			"{{/" + name + "}"
-			
-		};
+				"{{#"+name+"}",
+				"{{.}}",
+				"{{/" + name + "}"
+			};
 		}
 	}
 
@@ -112,7 +112,7 @@ public override void WriteJson(JsonWriter writer, object value, JsonSerializer s
 		{
 			var v = value as IIfTemplate;
 			if (v == null) writer.WriteNull();
-
+			var l = writer.Path.Split(new[] { '.' }).Length + 1;
 			writer.WriteRaw("{{#" + v.Variable + "}}");
 			serializer.Serialize(writer, v.Instance);
 			writer.WriteRaw("{{/" + v.Variable + "}}");

From 967e6edd40b462ff73453f37ed4510c3de6a2195 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 9 Sep 2014 05:17:00 +0200
Subject: [PATCH 04/15] post merge build failures

---
 .../Nest.Tests.Unit/Nest.Tests.Unit.csproj    |  5 +--
 .../Template/TemplateSpikeTests.cs            | 37 -------------------
 2 files changed, 1 insertion(+), 41 deletions(-)

diff --git a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
index aaafb84ca2e..e6e288e5c41 100644
--- a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
+++ b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
@@ -505,9 +505,7 @@
     <Compile Include="Search\Suggest\PhraseSuggestTests.cs" />
     <Compile Include="Search\Suggest\TermSuggestTests.cs" />
     <Compile Include="Settings\UsePrettyResponseTests.cs" />
-    <Compile Include="Template\TemplateSpikeTests.cs">
-      <SubType>Code</SubType>
-    </Compile>
+    <Compile Include="Template\TemplateSpikeTests.cs" />
     <Compile Include="TestElasticClient.cs" />
     <Compile Include="Core\Update\UpdateTests.cs" />
   </ItemGroup>
@@ -1249,7 +1247,6 @@
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
   </ItemGroup>
-  <ItemGroup />
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
   <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs b/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
index 4ed9d108e8b..b90d5ce402c 100644
--- a/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
+++ b/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
@@ -77,15 +77,6 @@ public void SearchTemplateByFile()
 			);
 		}
 
-		public static Func<SortFieldDescriptor<T>, IFieldSort> If<T>(string variable, Func<SortFieldDescriptor<T>, IFieldSort> s)
-		where T : class
-		{
-			return new Func<SortFieldDescriptor<T>, IFieldSort>(inner => new IfSortFieldDescriptor(variable, s(inner)));
-		}
-		public static QueryContainer If(string variable, QueryContainer o)
-		{
-			return new IfQueryContainer(variable, o);
-		}
 
 		[Test]
 		public void SearchTemplateById()
@@ -110,32 +101,4 @@ public static IEnumerable<string> Array(string name)
 			};
 		}
 	}
-
-	public class IfTemplateConverter : JsonConverter
-	{
-		public override bool CanWrite { get { return true; } }
-
-		public override bool CanRead { get { return false; } }
-
-		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-		{
-			var v = value as IIfTemplate;
-			if (v == null) writer.WriteNull();
-			var l = writer.Path.Split(new[] { '.' }).Length + 1;
-			writer.WriteRaw("{{#" + v.Variable + "}}");
-			serializer.Serialize(writer, v.Instance);
-			writer.WriteRaw("{{/" + v.Variable + "}}");
-
-		}
-
-		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-		{
-			return null;
-		}
-
-		public override bool CanConvert(Type objectType)
-		{
-			return true;
-		}
-	}
 }

From b0b917356ff6dcaf5e199082c62aadc9aa7a96f1 Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Thu, 18 Sep 2014 14:39:23 -0400
Subject: [PATCH 05/15] Add Params() overload that takes a FluentDictionary

---
 src/Nest/DSL/SearchTemplateDescriptor.cs | 12 ++++++++++--
 1 file changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/Nest/DSL/SearchTemplateDescriptor.cs b/src/Nest/DSL/SearchTemplateDescriptor.cs
index 42567163b8d..2789c782889 100644
--- a/src/Nest/DSL/SearchTemplateDescriptor.cs
+++ b/src/Nest/DSL/SearchTemplateDescriptor.cs
@@ -126,9 +126,17 @@ public SearchTemplateDescriptor<T> Template(Func<TemplateDescriptor, TemplateDes
 			return this;
 		}
 
-		public SearchTemplateDescriptor<T> Params(IDictionary<string, object> parameters)
+		public SearchTemplateDescriptor<T> Params(Dictionary<string, object> paramDictionary)
 		{
-			this.Self.Params = parameters;
+			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;
 		}
 

From 185d036eab2df2cdc3de14a458a230c9c24fdf15 Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Fri, 19 Sep 2014 12:15:23 -0400
Subject: [PATCH 06/15] Modifications to SearchTemplate() to better align with
 the api endpoint

---
 src/Nest/DSL/SearchTemplateDescriptor.cs      | 102 ++++++-----------
 .../Nest.Tests.Integration.csproj             |   1 +
 .../Search/Template/SearchTemplateTests.cs    |  36 ++++++
 .../Nest.Tests.Unit/Nest.Tests.Unit.csproj    |   1 -
 .../Template/TemplateSpikeTests.cs            | 104 ------------------
 5 files changed, 69 insertions(+), 175 deletions(-)
 create mode 100644 src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
 delete mode 100644 src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs

diff --git a/src/Nest/DSL/SearchTemplateDescriptor.cs b/src/Nest/DSL/SearchTemplateDescriptor.cs
index 2789c782889..791edbc1f65 100644
--- a/src/Nest/DSL/SearchTemplateDescriptor.cs
+++ b/src/Nest/DSL/SearchTemplateDescriptor.cs
@@ -53,12 +53,14 @@ public interface ISearchTemplateRequest
 
 		Type ClrType { get; }
 
-		[JsonProperty(PropertyName = "sort")]
-		[JsonConverter(typeof(SortCollectionConverter))]
-		IList<KeyValuePair<PropertyPathMarker, ISort>> Sort { get; set; }
-
 		[JsonProperty(PropertyName = "template")]
-		SearchTemplate Template { get; set; }
+		string Template { get; set; }
+
+		[JsonProperty("file")]
+		string File { get; set; }
+
+		[JsonProperty("id")]
+		string Id { get; set; }
 
 		Func<dynamic, Hit<dynamic>, Type> TypeSelector { get; set; }
 	}
@@ -68,11 +70,12 @@ public interface ISearchTemplateRequest<T> : ISearchTemplateRequest { }
 	public partial class SearchTemplateRequest 
 		: QueryPathBase<SearchTemplateRequestParameters>, ISearchTemplateRequest
 	{
-		public SearchTemplate Template { get; set; }
+		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 IList<KeyValuePair<PropertyPathMarker, ISort>> Sort { get; set; }
 		public Func<dynamic, Hit<dynamic>, Type> TypeSelector { get; set; }
 
 		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
@@ -85,10 +88,11 @@ public partial class SearchTemplateRequest<T>
 		: QueryPathBase<SearchTemplateRequestParameters, T>, ISearchTemplateRequest
 		where T : class
 	{
-		public SearchTemplate Template { get; set; }
+		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 IList<KeyValuePair<PropertyPathMarker, ISort>> Sort { get; set; }
 		public Func<dynamic, Hit<dynamic>, Type> TypeSelector { get; set; }
 
 		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
@@ -110,19 +114,31 @@ public partial class SearchTemplateDescriptor<T>
 		/// </summary>
 		internal bool _Strict { get; set; }
 
-		SearchTemplate ISearchTemplateRequest.Template { get; set; }
+		string ISearchTemplateRequest.Template { get; set; }
 
-		IDictionary<string, object> ISearchTemplateRequest.Params { get; set; }
+		string ISearchTemplateRequest.File { get; set; }
 
-		IList<KeyValuePair<PropertyPathMarker, ISort>> ISearchTemplateRequest.Sort { 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(Func<TemplateDescriptor, TemplateDescriptor> templateSelector)
+		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)
 		{
-			templateSelector.ThrowIfNull("templateSelector");
-			var descriptor = templateSelector(new TemplateDescriptor());
-			this.Self.Template = descriptor.Template;
+			this.Self.Id = id;
 			return this;
 		}
 
@@ -140,21 +156,6 @@ public SearchTemplateDescriptor<T> Params(Func<FluentDictionary<string, object>,
 			return this;
 		}
 
-		/// <summary>
-		/// <para>Sort() allows you to fully describe your sort unlike the SortAscending and SortDescending aliases.
-		/// </para>
-		/// </summary>
-		public SearchTemplateDescriptor<T> Sort(Func<SortFieldDescriptor<T>, IFieldSort> sortSelector)
-		{
-			if (Self.Sort == null)
-				Self.Sort = new List<KeyValuePair<PropertyPathMarker, ISort>>();
-
-			sortSelector.ThrowIfNull("sortSelector");
-			var descriptor = sortSelector(new SortFieldDescriptor<T>());
-			Self.Sort.Add(new KeyValuePair<PropertyPathMarker, ISort>(descriptor.Field, descriptor));
-			return this;
-		}
-
 		public SearchTemplateDescriptor<T> ConcreteTypeSelector(Func<dynamic, Hit<dynamic>, Type> typeSelector)
 		{
 			Self.TypeSelector = typeSelector;
@@ -166,43 +167,4 @@ protected override void UpdatePathInfo(IConnectionSettingsValues settings, Elast
 			SearchTemplatePathInfo.Update(pathInfo);
 		}
 	}
-
-	[JsonObject]
-	public class SearchTemplate
-	{
-		[JsonProperty("file")]
-		public string File { get; set; }
-
-		[JsonProperty("id")]
-		public string Id { get; set; }
-
-		[JsonProperty("query")]
-		public IQueryContainer Query { get; set; }
-	}
-
-	public class TemplateDescriptor
-	{
-		public SearchTemplate Template = new SearchTemplate();
-
-		public TemplateDescriptor File(string file)
-		{
-			Template.File = file;
-			return this;
-		}
-
-		public TemplateDescriptor Id(string id)
-		{
-			Template.Id = id;
-			return this;
-		}
-
-		public TemplateDescriptor Query<T>(Func<QueryDescriptor<T>, QueryContainer> query) where T : class
-		{
-			query.ThrowIfNull("query");
-			var q = new QueryDescriptor<T>();
-			((IQueryContainer)q).IsStrict = true;
-			Template.Query = query(q);
-			return this;
-		}
-	}
 }
diff --git a/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj b/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
index a953583c60a..50de0a05cbd 100644
--- a/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
+++ b/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
@@ -232,6 +232,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" />
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..528ddbed5fd
--- /dev/null
+++ b/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
@@ -0,0 +1,36 @@
+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
+	{
+		[Test]
+		public void SearchTemplateByQuery()
+		{
+			var template = "{\"from\": \"{{my_from}}\",\"size\": \"{{my_size}}\",\"query\": { \"match\": {\"{{my_field}}\": {\"query\": \"{{my_value}}\" }}}}";
+
+			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);
+		}
+	}
+}
+
diff --git a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
index e6e288e5c41..77e9441ad9a 100644
--- a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
+++ b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
@@ -505,7 +505,6 @@
     <Compile Include="Search\Suggest\PhraseSuggestTests.cs" />
     <Compile Include="Search\Suggest\TermSuggestTests.cs" />
     <Compile Include="Settings\UsePrettyResponseTests.cs" />
-    <Compile Include="Template\TemplateSpikeTests.cs" />
     <Compile Include="TestElasticClient.cs" />
     <Compile Include="Core\Update\UpdateTests.cs" />
   </ItemGroup>
diff --git a/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs b/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
deleted file mode 100644
index b90d5ce402c..00000000000
--- a/src/Tests/Nest.Tests.Unit/Template/TemplateSpikeTests.cs
+++ /dev/null
@@ -1,104 +0,0 @@
-using Elasticsearch.Net;
-using Elasticsearch.Net.Connection;
-using FluentAssertions;
-using Nest;
-using Nest.Tests.MockData.Domain;
-using Newtonsoft.Json;
-using NUnit.Framework;
-using System;
-using System.Collections.Generic;
-
-namespace Nest.Tests.Unit.Template
-{
-	[TestFixture]
-	public class TemplateSpikeTests : BaseJsonTests
-	{
-		[Test]
-		public void Print()
-		{
-
-			var search = this._client.Search<ElasticsearchProject>(s => s
-					.Strict()
-					.Query(q =>
-						TemplateBuilder.Section("start",
-							q.Range(r => r
-								.OnField("fieldx")
-								.Greater(TemplateBuilder.Variable("start"))
-								.Lower(TemplateBuilder.Variable("end", "20"))
-							)
-						)
-						&& TemplateBuilder.Section("other_var", new TermQuery()
-						{
-							Field = TemplateBuilder.Variable("myfield"),
-							Value = TemplateBuilder.Variable("myval")
-						})
-						&& q.Terms("field", TemplateBuilder.Array("array"))
-					)
-					.Sort(TemplateBuilder.Section<ElasticsearchProject>("sort", sort => sort.Ascending().OnField("{{sort}}")))
-				);
-
-			Assert.Fail(search.ConnectionStatus.ToString());
-		}
-
-		[Test]
-		public void SearchTemplateByQuery()
-		{
-			var search = this._client.SearchTemplate<ElasticsearchProject>(s => s
-				.Template(t => t
-					.Query<object>(q =>
-						TemplateBuilder.Section("start", q.Match(m => m
-								.OnField(TemplateBuilder.Variable("my_field"))
-								.Query(TemplateBuilder.Variable("my_value"))
-							)
-						)
-					)
-				)
-				.Params(new Dictionary<string, object>
-					{
-						{ "my_field", "foo" },
-						{ "my_value", "bar" }
-					}
-				)
-			);
-		}
-
-		[Test]
-		public void SearchTemplateByFile()
-		{
-			var search = this._client.SearchTemplate<ElasticsearchProject>(s => s
-				.Template(t => t
-					.File("myTemplate.mustache")
-				)
-				.Params(new Dictionary<string, object>
-				{
-					{ "my_field", "foo" },
-					{ "my_value", "bar" }
-				})
-			);
-		}
-
-
-		[Test]
-		public void SearchTemplateById()
-		{
-			var search = this._client.SearchTemplate<ElasticsearchProject>(s => s
-				.Template(t => t
-					.Id("myTemplateName")
-				)
-				.Params(new Dictionary<string, object>
-				{
-					{ "my_field", "foo" },
-					{ "my_value", "bar" }
-				})
-			);
-		}
-		public static IEnumerable<string> Array(string name)
-		{
-			return new[] {
-				"{{#"+name+"}",
-				"{{.}}",
-				"{{/" + name + "}"
-			};
-		}
-	}
-}

From 63c088a2b3355fbd114da4fe2096b41f37cfd8bf Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Fri, 19 Sep 2014 13:39:59 -0400
Subject: [PATCH 07/15] Add async and OIS search template variants

---
 src/Nest/ElasticClient-SearchTemplate.cs      | 74 ++++++++++++++++++-
 src/Nest/IElasticClient.cs                    | 39 ++++++++++
 .../Search/Template/SearchTemplateTests.cs    | 27 ++++++-
 3 files changed, 136 insertions(+), 4 deletions(-)

diff --git a/src/Nest/ElasticClient-SearchTemplate.cs b/src/Nest/ElasticClient-SearchTemplate.cs
index 65f1569a009..88a59b8ba7e 100644
--- a/src/Nest/ElasticClient-SearchTemplate.cs
+++ b/src/Nest/ElasticClient-SearchTemplate.cs
@@ -5,10 +5,11 @@
 using System.IO;
 using System.Linq;
 using System.Text;
+using System.Threading.Tasks;
 
 namespace Nest
 {
-	public partial class ElasticClient
+	public partial class ElasticClient : IElasticClient
 	{
 		public ISearchResponse<T> SearchTemplate<T>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector) where T : class
 		{
@@ -31,6 +32,77 @@ public ISearchResponse<TResult> SearchTemplate<T, TResult>(Func<SearchTemplateDe
 			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);
+				});
+		}
+
 		private SearchResponse<TResult> FieldsSearchDeserializer<T, TResult>(IElasticsearchResponse response, Stream stream, ISearchTemplateRequest d)
 			where T : class
 			where TResult : class
diff --git a/src/Nest/IElasticClient.cs b/src/Nest/IElasticClient.cs
index c201ff0ac6d..6537b48fc77 100644
--- a/src/Nest/IElasticClient.cs
+++ b/src/Nest/IElasticClient.cs
@@ -774,9 +774,48 @@ 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;
+
 		/// <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/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs b/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
index 528ddbed5fd..c442e401562 100644
--- a/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
@@ -13,13 +13,13 @@ 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 template = "{\"from\": \"{{my_from}}\",\"size\": \"{{my_size}}\",\"query\": { \"match\": {\"{{my_field}}\": {\"query\": \"{{my_value}}\" }}}}";
-
 			var result = this.Client.SearchTemplate<ElasticsearchProject>(s => s
-				.Template(template)
+				.Template(_template)
 				.Params(p => p
 					.Add("my_from", 0)
 					.Add("my_size", 5)
@@ -31,6 +31,27 @@ public void SearchTemplateByQuery()
 			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);
+		}
 	}
 }
 

From 6b1f59c7a161923a34fb231d92e8f005c13b7661 Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Fri, 19 Sep 2014 15:30:31 -0400
Subject: [PATCH 08/15] Partial support for Get/Put/Delete search templates

---
 .../DSL/DeleteSearchTemplateDescriptor.cs     | 44 +++++++++++++
 src/Nest/DSL/GetSearchTemplateDescriptor.cs   | 46 ++++++++++++++
 src/Nest/DSL/PutSearchTemplateDescriptor.cs   | 45 ++++++++++++++
 .../Responses/DeleteSearchTemplateResponse.cs | 15 +++++
 .../Responses/GetSearchTemplateResponse.cs    | 15 +++++
 .../Responses/PutSearchTemplateResponse.cs    | 16 +++++
 src/Nest/ElasticClient-SearchTemplate.cs      | 62 ++++++++++++++++++-
 src/Nest/IElasticClient.cs                    | 36 +++++++++++
 src/Nest/Nest.csproj                          |  6 ++
 9 files changed, 284 insertions(+), 1 deletion(-)
 create mode 100644 src/Nest/DSL/DeleteSearchTemplateDescriptor.cs
 create mode 100644 src/Nest/DSL/GetSearchTemplateDescriptor.cs
 create mode 100644 src/Nest/DSL/PutSearchTemplateDescriptor.cs
 create mode 100644 src/Nest/Domain/Responses/DeleteSearchTemplateResponse.cs
 create mode 100644 src/Nest/Domain/Responses/GetSearchTemplateResponse.cs
 create mode 100644 src/Nest/Domain/Responses/PutSearchTemplateResponse.cs

diff --git a/src/Nest/DSL/DeleteSearchTemplateDescriptor.cs b/src/Nest/DSL/DeleteSearchTemplateDescriptor.cs
new file mode 100644
index 00000000000..e81e1bc091d
--- /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<SearchTemplateRequestParameters> { }
+
+	public partial class DeleteSearchTemplateRequest 
+		: NamePathBase<SearchTemplateRequestParameters>, IDeleteSearchTemplateRequest
+	{
+		public DeleteSearchTemplateRequest(string templateName)
+			: base(templateName)
+		{
+		}
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			DeleteSearchTemplatePathInfo.Update(pathInfo);
+		}
+	}
+
+	internal static class DeleteSearchTemplatePathInfo
+	{
+		public static void Update(ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
+		}
+	}
+
+	[DescriptorFor("SearchTemplateDelete")]
+	public partial class DeleteSearchTemplateDescriptor 
+		: NamePathDescriptor<DeleteSearchTemplateDescriptor, SearchTemplateRequestParameters>, IDeleteSearchTemplateRequest
+	{
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			DeleteSearchTemplatePathInfo.Update(pathInfo);
+		}
+	}
+}
diff --git a/src/Nest/DSL/GetSearchTemplateDescriptor.cs b/src/Nest/DSL/GetSearchTemplateDescriptor.cs
new file mode 100644
index 00000000000..bd592ff4faa
--- /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<SearchTemplateRequestParameters>
+	{
+	}
+
+	public partial class GetSearchTemplateRequest 
+		: NamePathBase<SearchTemplateRequestParameters>, IGetSearchTemplateRequest
+	{
+		public GetSearchTemplateRequest(string templateName)
+			: base(templateName)
+		{
+		}
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			GetSearchTemplatePathInfo.Update(pathInfo);
+		}
+	}
+
+	internal static class GetSearchTemplatePathInfo
+	{
+		public static void Update(ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
+		}
+	}
+
+	[DescriptorFor("SearchTemplateGet")]
+	public partial class GetSearchTemplateDescriptor 
+		: NamePathDescriptor<GetSearchTemplateDescriptor, SearchTemplateRequestParameters>, IGetSearchTemplateRequest
+	{
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			GetSearchTemplatePathInfo.Update(pathInfo);
+		}
+	}
+}
diff --git a/src/Nest/DSL/PutSearchTemplateDescriptor.cs b/src/Nest/DSL/PutSearchTemplateDescriptor.cs
new file mode 100644
index 00000000000..dda2c3ef29b
--- /dev/null
+++ b/src/Nest/DSL/PutSearchTemplateDescriptor.cs
@@ -0,0 +1,45 @@
+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<SearchTemplateRequestParameters>
+	{
+	}
+
+	public partial class PutSearchTemplateRequest : NamePathBase<SearchTemplateRequestParameters>, IPutSearchTemplateRequest
+	{
+		public PutSearchTemplateRequest(string templateName)
+			: base(templateName)
+		{
+		}
+
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			PutSearchTemplatePathInfo.Update(pathInfo);
+		}
+	}
+
+	internal static class PutSearchTemplatePathInfo
+	{
+		public static void Update(ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
+		}
+	}
+
+	[DescriptorFor("SearchTemplatePut")]
+	public partial class PutSearchTemplateDescriptor
+		: NamePathDescriptor<PutSearchTemplateDescriptor, SearchTemplateRequestParameters>, IPutSearchTemplateRequest
+	{
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		{
+			PutSearchTemplatePathInfo.Update(pathInfo);
+		}
+	}
+}
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..313919fe914
--- /dev/null
+++ b/src/Nest/Domain/Responses/GetSearchTemplateResponse.cs
@@ -0,0 +1,15 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Nest
+{
+	public interface IGetSearchTemplateResponse : IResponse
+	{
+	}
+
+	public class GetSearchTemplateResponse : BaseResponse, IGetSearchTemplateResponse
+	{
+	}
+}
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
index 88a59b8ba7e..f120b4e2775 100644
--- a/src/Nest/ElasticClient-SearchTemplate.cs
+++ b/src/Nest/ElasticClient-SearchTemplate.cs
@@ -9,7 +9,7 @@
 
 namespace Nest
 {
-	public partial class ElasticClient : IElasticClient
+	public partial class ElasticClient
 	{
 		public ISearchResponse<T> SearchTemplate<T>(Func<SearchTemplateDescriptor<T>, SearchTemplateDescriptor<T>> selector) where T : class
 		{
@@ -131,5 +131,65 @@ private JsonConverter CreateCovariantSearchSelector<T, TResult>(ISearchTemplateR
 			SearchTemplatePathInfo.CloseOverAutomagicCovariantResultSelector(this.Infer, originalSearchDescriptor);
 			return originalSearchDescriptor.TypeSelector == null ? null : new ConcreteTypeConverter<TResult>(originalSearchDescriptor.TypeSelector);
 		}
+
+		public IGetSearchTemplateResponse GetSearchTemplate(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector)
+		{
+			throw new NotImplementedException();
+		}
+
+		public IGetSearchTemplateResponse GetSearchTemplate(IGetSearchTemplateRequest request)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(IGetSearchTemplateRequest request)
+		{
+			throw new NotImplementedException();
+		}
+
+		public IPutSearchTemplateResponse PutSearchTemplate(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector)
+		{
+			throw new NotImplementedException();
+		}
+
+		public IPutSearchTemplateResponse PutSearchTemplate(IPutSearchTemplateRequest request)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(IPutSearchTemplateRequest request)
+		{
+			throw new NotImplementedException();
+		}
+
+		public IDeleteSearchTemplateResponse DeleteSearchTemplate(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector)
+		{
+			throw new NotImplementedException();
+		}
+
+		public IDeleteSearchTemplateResponse DeleteSearchTemplate(IDeleteSearchTemplateRequest request)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(IDeleteSearchTemplateRequest request)
+		{
+			throw new NotImplementedException();
+		}
 	}
 }
diff --git a/src/Nest/IElasticClient.cs b/src/Nest/IElasticClient.cs
index 6537b48fc77..114a9d5f604 100644
--- a/src/Nest/IElasticClient.cs
+++ b/src/Nest/IElasticClient.cs
@@ -816,6 +816,42 @@ Task<ISearchResponse<TResult>> SearchTemplateAsync<T, TResult>(ISearchTemplateRe
 			where T : class
 			where TResult : class;
 
+		/// <inheritdoc />
+		IGetSearchTemplateResponse GetSearchTemplate(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector);
+
+		/// <inheritdoc />
+		IGetSearchTemplateResponse GetSearchTemplate(IGetSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector);
+
+		/// <inheritdoc />
+		Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(IGetSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		IPutSearchTemplateResponse PutSearchTemplate(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector);
+
+		/// <inheritdoc />
+		IPutSearchTemplateResponse PutSearchTemplate(IPutSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector);
+
+		/// <inheritdoc />
+		Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(IPutSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		IDeleteSearchTemplateResponse DeleteSearchTemplate(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector);
+
+		/// <inheritdoc />
+		IDeleteSearchTemplateResponse DeleteSearchTemplate(IDeleteSearchTemplateRequest request);
+
+		/// <inheritdoc />
+		Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector);
+
+		/// <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 aa5384f9efd..2b6d9b7f107 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" />
@@ -196,6 +199,9 @@
     <Compile Include="Domain\Stats\SegmentsStats.cs" />
     <Compile Include="Domain\Template\ITemplateSection.cs" />
     <Compile Include="Domain\Template\TemplateBuilder.cs" />
+    <Compile Include="DSL\PutSearchTemplateDescriptor.cs" />
+    <Compile Include="DSL\DeleteSearchTemplateDescriptor.cs" />
+    <Compile Include="DSL\GetSearchTemplateDescriptor.cs" />
     <Compile Include="DSL\Template\TemplateSectionQueryContainer.cs" />
     <Compile Include="DSL\Template\TemplateSectionSortFieldDescriptor.cs" />
     <Compile Include="DSL\CatIndicesDescriptor.cs" />

From aeb4a89514e33934bb70fea62318cd3499e144d6 Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Fri, 19 Sep 2014 15:59:16 -0400
Subject: [PATCH 09/15] Update generated classes

---
 .../Descriptors/SearchDescriptorOverrides.cs  |    3 +-
 .../RequestParameters.Generated.cs            |  124 +-
 .../ElasticsearchClient.Generated.cs          | 1208 ++++++++++++++++-
 .../IElasticsearchClient.Generated.cs         |  640 +++++++++
 src/Nest/DSL/_Descriptors.generated.cs        |  151 ++-
 src/Nest/DSL/_Requests.generated.cs           |  132 +-
 .../Domain/Paths/ElasticSearchPathInfo.cs     |    2 +
 src/Nest/RawDispatch.generated.cs             |  204 +++
 8 files changed, 2268 insertions(+), 196 deletions(-)

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/_Descriptors.generated.cs b/src/Nest/DSL/_Descriptors.generated.cs
index de4c770f304..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();
+		}
+		
+	
 	}
 	
 	
diff --git a/src/Nest/DSL/_Requests.generated.cs b/src/Nest/DSL/_Requests.generated.cs
index 89eb2f87753..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
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/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)

From 33a1fc31d4a01e85b1dfc217c52809cce2d8b2cf Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Fri, 19 Sep 2014 20:26:30 -0400
Subject: [PATCH 10/15] Complete support for Get/Put/Delete search templates
 with integrations tests

---
 .../DSL/DeleteSearchTemplateDescriptor.cs     |  20 +--
 src/Nest/DSL/GetSearchTemplateDescriptor.cs   |  18 +--
 src/Nest/DSL/PutSearchTemplateDescriptor.cs   |  30 +++--
 .../Responses/GetSearchTemplateResponse.cs    |   7 +-
 src/Nest/ElasticClient-SearchTemplate.cs      | 124 ++++++++++++------
 .../Search/Template/SearchTemplateTests.cs    |  46 +++++++
 6 files changed, 176 insertions(+), 69 deletions(-)

diff --git a/src/Nest/DSL/DeleteSearchTemplateDescriptor.cs b/src/Nest/DSL/DeleteSearchTemplateDescriptor.cs
index e81e1bc091d..03a5d4757a9 100644
--- a/src/Nest/DSL/DeleteSearchTemplateDescriptor.cs
+++ b/src/Nest/DSL/DeleteSearchTemplateDescriptor.cs
@@ -8,37 +8,37 @@
 namespace Nest
 {
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
-	public interface IDeleteSearchTemplateRequest : INamePath<SearchTemplateRequestParameters> { }
+	public interface IDeleteSearchTemplateRequest : INamePath<DeleteTemplateRequestParameters> { }
 
 	public partial class DeleteSearchTemplateRequest 
-		: NamePathBase<SearchTemplateRequestParameters>, IDeleteSearchTemplateRequest
+		: NamePathBase<DeleteTemplateRequestParameters>, IDeleteSearchTemplateRequest
 	{
 		public DeleteSearchTemplateRequest(string templateName)
 			: base(templateName)
 		{
 		}
 
-		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo)
 		{
-			DeleteSearchTemplatePathInfo.Update(pathInfo);
+			DeleteSearchTemplatePathInfo.Update(pathInfo, this);
 		}
 	}
 
 	internal static class DeleteSearchTemplatePathInfo
 	{
-		public static void Update(ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		public static void Update(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo, IDeleteSearchTemplateRequest request)
 		{
-			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
+			pathInfo.Id = request.Name;
+			pathInfo.HttpMethod = PathInfoHttpMethod.DELETE;
 		}
 	}
 
-	[DescriptorFor("SearchTemplateDelete")]
 	public partial class DeleteSearchTemplateDescriptor 
-		: NamePathDescriptor<DeleteSearchTemplateDescriptor, SearchTemplateRequestParameters>, IDeleteSearchTemplateRequest
+		: NamePathDescriptor<DeleteSearchTemplateDescriptor, DeleteTemplateRequestParameters>, IDeleteSearchTemplateRequest
 	{
-		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo)
 		{
-			DeleteSearchTemplatePathInfo.Update(pathInfo);
+			DeleteSearchTemplatePathInfo.Update(pathInfo, this);
 		}
 	}
 }
diff --git a/src/Nest/DSL/GetSearchTemplateDescriptor.cs b/src/Nest/DSL/GetSearchTemplateDescriptor.cs
index bd592ff4faa..dd54f9a127a 100644
--- a/src/Nest/DSL/GetSearchTemplateDescriptor.cs
+++ b/src/Nest/DSL/GetSearchTemplateDescriptor.cs
@@ -8,39 +8,39 @@
 namespace Nest
 {
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
-	public interface IGetSearchTemplateRequest : INamePath<SearchTemplateRequestParameters>
+	public interface IGetSearchTemplateRequest : INamePath<GetTemplateRequestParameters>
 	{
 	}
 
 	public partial class GetSearchTemplateRequest 
-		: NamePathBase<SearchTemplateRequestParameters>, IGetSearchTemplateRequest
+		: NamePathBase<GetTemplateRequestParameters>, IGetSearchTemplateRequest
 	{
 		public GetSearchTemplateRequest(string templateName)
 			: base(templateName)
 		{
 		}
 
-		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo)
 		{
-			GetSearchTemplatePathInfo.Update(pathInfo);
+			GetSearchTemplatePathInfo.Update(pathInfo, this);
 		}
 	}
 
 	internal static class GetSearchTemplatePathInfo
 	{
-		public static void Update(ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		public static void Update(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo, IGetSearchTemplateRequest request)
 		{
+			pathInfo.Id = request.Name;
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 		}
 	}
 
-	[DescriptorFor("SearchTemplateGet")]
 	public partial class GetSearchTemplateDescriptor 
-		: NamePathDescriptor<GetSearchTemplateDescriptor, SearchTemplateRequestParameters>, IGetSearchTemplateRequest
+		: NamePathDescriptor<GetSearchTemplateDescriptor, GetTemplateRequestParameters>, IGetSearchTemplateRequest
 	{
-		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo)
 		{
-			GetSearchTemplatePathInfo.Update(pathInfo);
+			GetSearchTemplatePathInfo.Update(pathInfo, this);
 		}
 	}
 }
diff --git a/src/Nest/DSL/PutSearchTemplateDescriptor.cs b/src/Nest/DSL/PutSearchTemplateDescriptor.cs
index dda2c3ef29b..60c459fd0d8 100644
--- a/src/Nest/DSL/PutSearchTemplateDescriptor.cs
+++ b/src/Nest/DSL/PutSearchTemplateDescriptor.cs
@@ -8,38 +8,52 @@
 namespace Nest
 {
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
-	public interface IPutSearchTemplateRequest : INamePath<SearchTemplateRequestParameters>
+	public interface IPutSearchTemplateRequest : INamePath<PutTemplateRequestParameters>
 	{
+		[JsonProperty("template")]
+		string Template { get; set; }
 	}
 
-	public partial class PutSearchTemplateRequest : NamePathBase<SearchTemplateRequestParameters>, IPutSearchTemplateRequest
+	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<SearchTemplateRequestParameters> pathInfo)
+		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo)
 		{
-			PutSearchTemplatePathInfo.Update(pathInfo);
+			PutSearchTemplatePathInfo.Update(pathInfo, this);
 		}
 	}
 
 	internal static class PutSearchTemplatePathInfo
 	{
-		public static void Update(ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		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, SearchTemplateRequestParameters>, IPutSearchTemplateRequest
+		: NamePathDescriptor<PutSearchTemplateDescriptor, PutTemplateRequestParameters>, IPutSearchTemplateRequest
 	{
-		protected override void UpdatePathInfo(IConnectionSettingsValues settings, ElasticsearchPathInfo<SearchTemplateRequestParameters> pathInfo)
+		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);
+			PutSearchTemplatePathInfo.Update(pathInfo, this);
 		}
 	}
 }
diff --git a/src/Nest/Domain/Responses/GetSearchTemplateResponse.cs b/src/Nest/Domain/Responses/GetSearchTemplateResponse.cs
index 313919fe914..a0cbd19b29c 100644
--- a/src/Nest/Domain/Responses/GetSearchTemplateResponse.cs
+++ b/src/Nest/Domain/Responses/GetSearchTemplateResponse.cs
@@ -1,4 +1,5 @@
-using System;
+using Newtonsoft.Json;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
@@ -7,9 +8,13 @@ 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/ElasticClient-SearchTemplate.cs b/src/Nest/ElasticClient-SearchTemplate.cs
index f120b4e2775..60a2404c5ca 100644
--- a/src/Nest/ElasticClient-SearchTemplate.cs
+++ b/src/Nest/ElasticClient-SearchTemplate.cs
@@ -103,93 +103,135 @@ public Task<ISearchResponse<TResult>> SearchTemplateAsync<T, TResult>(ISearchTem
 				});
 		}
 
-		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);
-		}
-
 		public IGetSearchTemplateResponse GetSearchTemplate(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector)
 		{
-			throw new NotImplementedException();
+			selector = selector ?? (s => s);
+			return this.Dispatch<GetSearchTemplateDescriptor, GetTemplateRequestParameters, GetSearchTemplateResponse>(
+				selector,
+				(p, d) => this.RawDispatch.GetTemplateDispatch<GetSearchTemplateResponse>(p, d)
+			);
 		}
 
 		public IGetSearchTemplateResponse GetSearchTemplate(IGetSearchTemplateRequest request)
 		{
-			throw new NotImplementedException();
+			return this.Dispatch<IGetSearchTemplateRequest, GetTemplateRequestParameters, GetSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.GetTemplateDispatch<GetSearchTemplateResponse>(p, d)
+			);
 		}
 
 		public Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector)
 		{
-			throw new NotImplementedException();
+			selector = selector ?? (s => s);
+			return this.DispatchAsync<GetSearchTemplateDescriptor, GetTemplateRequestParameters, GetSearchTemplateResponse, IGetSearchTemplateResponse>(
+				selector,
+				(p, d) => this.RawDispatch.GetTemplateDispatchAsync<GetSearchTemplateResponse>(p, d)
+			);
 		}
 
 		public Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(IGetSearchTemplateRequest request)
 		{
-			throw new NotImplementedException();
+			return this.DispatchAsync<IGetSearchTemplateRequest, GetTemplateRequestParameters, GetSearchTemplateResponse, IGetSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.GetTemplateDispatchAsync<GetSearchTemplateResponse>(p, d)
+			);
 		}
 
 		public IPutSearchTemplateResponse PutSearchTemplate(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector)
 		{
-			throw new NotImplementedException();
+			selector = selector ?? (s => s);
+			return this.Dispatch<PutSearchTemplateDescriptor, PutTemplateRequestParameters, PutSearchTemplateResponse>(
+				selector,
+				(p, d) => this.RawDispatch.PutTemplateDispatch<PutSearchTemplateResponse>(p, d)
+			);
 		}
 
 		public IPutSearchTemplateResponse PutSearchTemplate(IPutSearchTemplateRequest request)
 		{
-			throw new NotImplementedException();
+			return this.Dispatch<IPutSearchTemplateRequest, PutTemplateRequestParameters, PutSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.PutTemplateDispatch<PutSearchTemplateResponse>(p, d)
+			);
 		}
 
 		public Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector)
 		{
-			throw new NotImplementedException();
+			selector = selector ?? (s => s);
+			return this.DispatchAsync<PutSearchTemplateDescriptor, PutTemplateRequestParameters, PutSearchTemplateResponse, IPutSearchTemplateResponse>(
+				selector,
+				(p, d) => this.RawDispatch.PutTemplateDispatchAsync<PutSearchTemplateResponse>(p, d)
+			);
 		}
 
 		public Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(IPutSearchTemplateRequest request)
 		{
-			throw new NotImplementedException();
+			return this.DispatchAsync<IPutSearchTemplateRequest, PutTemplateRequestParameters, PutSearchTemplateResponse, IPutSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.PutTemplateDispatchAsync<PutSearchTemplateResponse>(p, d)
+			);
 		}
 
 		public IDeleteSearchTemplateResponse DeleteSearchTemplate(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector)
 		{
-			throw new NotImplementedException();
+			selector = selector ?? (s => s);
+			return this.Dispatch<DeleteSearchTemplateDescriptor, DeleteTemplateRequestParameters, DeleteSearchTemplateResponse>(
+				selector,
+				(p, d) => this.RawDispatch.DeleteTemplateDispatch<DeleteSearchTemplateResponse>(p)
+			);
 		}
 
 		public IDeleteSearchTemplateResponse DeleteSearchTemplate(IDeleteSearchTemplateRequest request)
 		{
-			throw new NotImplementedException();
+			return this.Dispatch<IDeleteSearchTemplateRequest, DeleteTemplateRequestParameters, DeleteSearchTemplateResponse>(
+				request,
+				(p, d) => this.RawDispatch.DeleteTemplateDispatch<DeleteSearchTemplateResponse>(p)
+			);
 		}
 
 		public Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector)
 		{
-			throw new NotImplementedException();
+			selector = selector ?? (s => s);
+			return this.DispatchAsync<DeleteSearchTemplateDescriptor, DeleteTemplateRequestParameters, DeleteSearchTemplateResponse, IDeleteSearchTemplateResponse>(
+				selector,
+				(p, d) => this.RawDispatch.DeleteTemplateDispatchAsync<DeleteSearchTemplateResponse>(p)
+			);
 		}
 
 		public Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(IDeleteSearchTemplateRequest request)
 		{
-			throw new NotImplementedException();
+			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/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs b/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
index c442e401562..a8a3edc4c6c 100644
--- a/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
@@ -52,6 +52,52 @@ public void SearchTemplateByQuery_ObjectInitializer()
 			result.IsValid.Should().BeTrue();
 			result.Hits.Count().Should().BeGreaterThan(0);
 		}
+
+		public void SearchTemplateById()
+		{
+			var templateName = "myIndexedTemplate";
+
+			var putTemplateResult = this.Client.PutSearchTemplate(t => t
+				.Name(templateName)
+				.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(t => t.Name(templateName));
+			deleteTemplateResult.IsValid.Should().BeTrue();
+		}
+
+		[Test]
+		public void PutGetAndDeleteTemplate()
+		{
+			var templateName = "myIndexedTemplate";
+
+			var putResult = this.Client.PutSearchTemplate(t => t
+					.Name(templateName)
+					.Template(_template)
+				);
+			putResult.IsValid.Should().BeTrue();
+
+			var getResult = this.Client.GetSearchTemplate(t => t.Name(templateName));
+			getResult.IsValid.Should().BeTrue();
+			getResult.Template.ShouldBeEquivalentTo(_template);
+			
+			var deleteResult = this.Client.DeleteSearchTemplate(t => t.Name(templateName));
+			deleteResult.IsValid.Should().BeTrue();
+		}
 	}
 }
 

From a364cd45808a019ae045ae0f868bf21a90a9f2a5 Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Fri, 19 Sep 2014 20:29:35 -0400
Subject: [PATCH 11/15] Move and rename indices template tests to reduce
 confusion with search templates

---
 .../TemplateTests.cs => Indices/IndicesTemplateTests.cs}      | 4 ++--
 .../Nest.Tests.Integration/Nest.Tests.Integration.csproj      | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename src/Tests/Nest.Tests.Integration/{Template/TemplateTests.cs => Indices/IndicesTemplateTests.cs} (97%)

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 50de0a05cbd..5241d0d81c0 100644
--- a/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
+++ b/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
@@ -240,7 +240,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>

From 2aa172e3695fe9e21fd2231492ddb4c4f2a6b1f6 Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Fri, 19 Sep 2014 20:47:57 -0400
Subject: [PATCH 12/15] Enforce search template name on fluent API

---
 src/Nest/ElasticClient-SearchTemplate.cs      | 24 +++++++++----------
 src/Nest/IElasticClient.cs                    | 12 +++++-----
 .../Search/Template/SearchTemplateTests.cs    | 17 +++++--------
 3 files changed, 24 insertions(+), 29 deletions(-)

diff --git a/src/Nest/ElasticClient-SearchTemplate.cs b/src/Nest/ElasticClient-SearchTemplate.cs
index 60a2404c5ca..aa10f70276b 100644
--- a/src/Nest/ElasticClient-SearchTemplate.cs
+++ b/src/Nest/ElasticClient-SearchTemplate.cs
@@ -103,11 +103,11 @@ public Task<ISearchResponse<TResult>> SearchTemplateAsync<T, TResult>(ISearchTem
 				});
 		}
 
-		public IGetSearchTemplateResponse GetSearchTemplate(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector)
+		public IGetSearchTemplateResponse GetSearchTemplate(string name, Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
 			return this.Dispatch<GetSearchTemplateDescriptor, GetTemplateRequestParameters, GetSearchTemplateResponse>(
-				selector,
+				d => selector(d.Name(name)),
 				(p, d) => this.RawDispatch.GetTemplateDispatch<GetSearchTemplateResponse>(p, d)
 			);
 		}
@@ -120,11 +120,11 @@ public IGetSearchTemplateResponse GetSearchTemplate(IGetSearchTemplateRequest re
 			);
 		}
 
-		public Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector)
+		public Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(string name, Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
 			return this.DispatchAsync<GetSearchTemplateDescriptor, GetTemplateRequestParameters, GetSearchTemplateResponse, IGetSearchTemplateResponse>(
-				selector,
+				d => selector(d.Name(name)),
 				(p, d) => this.RawDispatch.GetTemplateDispatchAsync<GetSearchTemplateResponse>(p, d)
 			);
 		}
@@ -137,11 +137,11 @@ public Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(IGetSearchTemplat
 			);
 		}
 
-		public IPutSearchTemplateResponse PutSearchTemplate(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector)
+		public IPutSearchTemplateResponse PutSearchTemplate(string name, Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
 			return this.Dispatch<PutSearchTemplateDescriptor, PutTemplateRequestParameters, PutSearchTemplateResponse>(
-				selector,
+				d => selector(d.Name(name)),
 				(p, d) => this.RawDispatch.PutTemplateDispatch<PutSearchTemplateResponse>(p, d)
 			);
 		}
@@ -154,11 +154,11 @@ public IPutSearchTemplateResponse PutSearchTemplate(IPutSearchTemplateRequest re
 			);
 		}
 
-		public Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector)
+		public Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(string name, Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
 			return this.DispatchAsync<PutSearchTemplateDescriptor, PutTemplateRequestParameters, PutSearchTemplateResponse, IPutSearchTemplateResponse>(
-				selector,
+				d => selector(d.Name(name)),
 				(p, d) => this.RawDispatch.PutTemplateDispatchAsync<PutSearchTemplateResponse>(p, d)
 			);
 		}
@@ -171,11 +171,11 @@ public Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(IPutSearchTemplat
 			);
 		}
 
-		public IDeleteSearchTemplateResponse DeleteSearchTemplate(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector)
+		public IDeleteSearchTemplateResponse DeleteSearchTemplate(string name, Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
 			return this.Dispatch<DeleteSearchTemplateDescriptor, DeleteTemplateRequestParameters, DeleteSearchTemplateResponse>(
-				selector,
+				d => selector(d.Name(name)),
 				(p, d) => this.RawDispatch.DeleteTemplateDispatch<DeleteSearchTemplateResponse>(p)
 			);
 		}
@@ -188,11 +188,11 @@ public IDeleteSearchTemplateResponse DeleteSearchTemplate(IDeleteSearchTemplateR
 			);
 		}
 
-		public Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector)
+		public Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(string name, Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
 			return this.DispatchAsync<DeleteSearchTemplateDescriptor, DeleteTemplateRequestParameters, DeleteSearchTemplateResponse, IDeleteSearchTemplateResponse>(
-				selector,
+				d => selector(d.Name(name)),
 				(p, d) => this.RawDispatch.DeleteTemplateDispatchAsync<DeleteSearchTemplateResponse>(p)
 			);
 		}
diff --git a/src/Nest/IElasticClient.cs b/src/Nest/IElasticClient.cs
index 114a9d5f604..c2b91d09bcf 100644
--- a/src/Nest/IElasticClient.cs
+++ b/src/Nest/IElasticClient.cs
@@ -817,37 +817,37 @@ Task<ISearchResponse<TResult>> SearchTemplateAsync<T, TResult>(ISearchTemplateRe
 			where TResult : class;
 
 		/// <inheritdoc />
-		IGetSearchTemplateResponse GetSearchTemplate(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector);
+		IGetSearchTemplateResponse GetSearchTemplate(string name, Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector = null);
 
 		/// <inheritdoc />
 		IGetSearchTemplateResponse GetSearchTemplate(IGetSearchTemplateRequest request);
 
 		/// <inheritdoc />
-		Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector);
+		Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(string name, Func<GetSearchTemplateDescriptor, GetSearchTemplateDescriptor> selector = null);
 
 		/// <inheritdoc />
 		Task<IGetSearchTemplateResponse> GetSearchTemplateAsync(IGetSearchTemplateRequest request);
 
 		/// <inheritdoc />
-		IPutSearchTemplateResponse PutSearchTemplate(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector);
+		IPutSearchTemplateResponse PutSearchTemplate(string name, Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector = null);
 
 		/// <inheritdoc />
 		IPutSearchTemplateResponse PutSearchTemplate(IPutSearchTemplateRequest request);
 
 		/// <inheritdoc />
-		Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector);
+		Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(string name, Func<PutSearchTemplateDescriptor, PutSearchTemplateDescriptor> selector = null);
 
 		/// <inheritdoc />
 		Task<IPutSearchTemplateResponse> PutSearchTemplateAsync(IPutSearchTemplateRequest request);
 
 		/// <inheritdoc />
-		IDeleteSearchTemplateResponse DeleteSearchTemplate(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector);
+		IDeleteSearchTemplateResponse DeleteSearchTemplate(string name, Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector = null);
 
 		/// <inheritdoc />
 		IDeleteSearchTemplateResponse DeleteSearchTemplate(IDeleteSearchTemplateRequest request);
 
 		/// <inheritdoc />
-		Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector);
+		Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(string name, Func<DeleteSearchTemplateDescriptor, DeleteSearchTemplateDescriptor> selector = null);
 
 		/// <inheritdoc />
 		Task<IDeleteSearchTemplateResponse> DeleteSearchTemplateAsync(IDeleteSearchTemplateRequest request);
diff --git a/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs b/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
index a8a3edc4c6c..3e2a26523c5 100644
--- a/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Search/Template/SearchTemplateTests.cs
@@ -53,14 +53,12 @@ public void SearchTemplateByQuery_ObjectInitializer()
 			result.Hits.Count().Should().BeGreaterThan(0);
 		}
 
+		[Test]
 		public void SearchTemplateById()
 		{
 			var templateName = "myIndexedTemplate";
 
-			var putTemplateResult = this.Client.PutSearchTemplate(t => t
-				.Name(templateName)
-				.Template(_template)
-			);
+			var putTemplateResult = this.Client.PutSearchTemplate(templateName, t => t.Template(_template));
 			putTemplateResult.IsValid.Should().BeTrue();
 
 			var result = this.Client.SearchTemplate<ElasticsearchProject>(s => s
@@ -76,7 +74,7 @@ public void SearchTemplateById()
 			result.IsValid.Should().BeTrue();
 			result.Hits.Count().Should().BeGreaterThan(0);
 
-			var deleteTemplateResult = this.Client.DeleteSearchTemplate(t => t.Name(templateName));
+			var deleteTemplateResult = this.Client.DeleteSearchTemplate(templateName);
 			deleteTemplateResult.IsValid.Should().BeTrue();
 		}
 
@@ -85,17 +83,14 @@ public void PutGetAndDeleteTemplate()
 		{
 			var templateName = "myIndexedTemplate";
 
-			var putResult = this.Client.PutSearchTemplate(t => t
-					.Name(templateName)
-					.Template(_template)
-				);
+			var putResult = this.Client.PutSearchTemplate(templateName, t => t.Template(_template));
 			putResult.IsValid.Should().BeTrue();
 
-			var getResult = this.Client.GetSearchTemplate(t => t.Name(templateName));
+			var getResult = this.Client.GetSearchTemplate(templateName);
 			getResult.IsValid.Should().BeTrue();
 			getResult.Template.ShouldBeEquivalentTo(_template);
 			
-			var deleteResult = this.Client.DeleteSearchTemplate(t => t.Name(templateName));
+			var deleteResult = this.Client.DeleteSearchTemplate(templateName);
 			deleteResult.IsValid.Should().BeTrue();
 		}
 	}

From 86d9f5e5699feb8aa964c1b1e322f20db35f0f48 Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Mon, 22 Sep 2014 13:52:52 -0400
Subject: [PATCH 13/15] Add support for template query

---
 src/Nest/DSL/Query/IQueryContainer.cs         |  3 +
 src/Nest/DSL/Query/QueryContainer.cs          |  2 +
 src/Nest/DSL/Query/QueryDescriptor.cs         |  7 ++
 src/Nest/DSL/Query/TemplateQueryDescriptor.cs | 66 +++++++++++++++++
 src/Nest/Nest.csproj                          |  1 +
 .../Nest.Tests.Integration.csproj             |  1 +
 .../Search/Query/TemplateQueryTests.cs        | 35 +++++++++
 .../Nest.Tests.Unit/Nest.Tests.Unit.csproj    |  1 +
 .../Search/Query/Singles/TemplateQueryJson.cs | 74 +++++++++++++++++++
 9 files changed, 190 insertions(+)
 create mode 100644 src/Nest/DSL/Query/TemplateQueryDescriptor.cs
 create mode 100644 src/Tests/Nest.Tests.Integration/Search/Query/TemplateQueryTests.cs
 create mode 100644 src/Tests/Nest.Tests.Unit/Search/Query/Singles/TemplateQueryJson.cs

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/Nest.csproj b/src/Nest/Nest.csproj
index 2b6d9b7f107..11940c02c6d 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -202,6 +202,7 @@
     <Compile Include="DSL\PutSearchTemplateDescriptor.cs" />
     <Compile Include="DSL\DeleteSearchTemplateDescriptor.cs" />
     <Compile Include="DSL\GetSearchTemplateDescriptor.cs" />
+    <Compile Include="DSL\Query\TemplateQueryDescriptor.cs" />
     <Compile Include="DSL\Template\TemplateSectionQueryContainer.cs" />
     <Compile Include="DSL\Template\TemplateSectionSortFieldDescriptor.cs" />
     <Compile Include="DSL\CatIndicesDescriptor.cs" />
diff --git a/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj b/src/Tests/Nest.Tests.Integration/Nest.Tests.Integration.csproj
index 5241d0d81c0..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" />
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.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);
+		}
+	}
+}

From 30cd8d2cb7bcf82ad1e14e961a179fd1cf980cc4 Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Mon, 22 Sep 2014 15:07:25 -0400
Subject: [PATCH 14/15] Move query template classes to more appropriate folders

---
 .../DSL/{Template => Query}/TemplateSectionQueryContainer.cs  | 0
 .../TemplateSectionSortFieldDescriptor.cs                     | 0
 src/Nest/Nest.csproj                                          | 4 ++--
 3 files changed, 2 insertions(+), 2 deletions(-)
 rename src/Nest/DSL/{Template => Query}/TemplateSectionQueryContainer.cs (100%)
 rename src/Nest/DSL/{Template => Search}/TemplateSectionSortFieldDescriptor.cs (100%)

diff --git a/src/Nest/DSL/Template/TemplateSectionQueryContainer.cs b/src/Nest/DSL/Query/TemplateSectionQueryContainer.cs
similarity index 100%
rename from src/Nest/DSL/Template/TemplateSectionQueryContainer.cs
rename to src/Nest/DSL/Query/TemplateSectionQueryContainer.cs
diff --git a/src/Nest/DSL/Template/TemplateSectionSortFieldDescriptor.cs b/src/Nest/DSL/Search/TemplateSectionSortFieldDescriptor.cs
similarity index 100%
rename from src/Nest/DSL/Template/TemplateSectionSortFieldDescriptor.cs
rename to src/Nest/DSL/Search/TemplateSectionSortFieldDescriptor.cs
diff --git a/src/Nest/Nest.csproj b/src/Nest/Nest.csproj
index 11940c02c6d..fe15740a620 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -203,8 +203,8 @@
     <Compile Include="DSL\DeleteSearchTemplateDescriptor.cs" />
     <Compile Include="DSL\GetSearchTemplateDescriptor.cs" />
     <Compile Include="DSL\Query\TemplateQueryDescriptor.cs" />
-    <Compile Include="DSL\Template\TemplateSectionQueryContainer.cs" />
-    <Compile Include="DSL\Template\TemplateSectionSortFieldDescriptor.cs" />
+    <Compile Include="DSL\Query\TemplateSectionQueryContainer.cs" />
+    <Compile Include="DSL\Search\TemplateSectionSortFieldDescriptor.cs" />
     <Compile Include="DSL\CatIndicesDescriptor.cs" />
     <Compile Include="DSL\CatShardsDescriptor.cs" />
     <Compile Include="DSL\CatThreadPoolDescriptor.cs" />

From 4884d5b70de48789f5e501b1f113d999342a8353 Mon Sep 17 00:00:00 2001
From: Greg Marzouka <greg.marzouka@gmail.com>
Date: Mon, 6 Oct 2014 09:40:26 -0400
Subject: [PATCH 15/15] Remove TemplateSection and TemplateBuilder classes

---
 .../Query/TemplateSectionQueryContainer.cs    | 24 ------------
 .../TemplateSectionSortFieldDescriptor.cs     | 23 -----------
 src/Nest/Domain/Template/ITemplateSection.cs  | 13 -------
 src/Nest/Domain/Template/TemplateBuilder.cs   | 38 -------------------
 src/Nest/Nest.csproj                          |  5 ---
 .../Converters/TemplateSectionConverter.cs    | 35 -----------------
 6 files changed, 138 deletions(-)
 delete mode 100644 src/Nest/DSL/Query/TemplateSectionQueryContainer.cs
 delete mode 100644 src/Nest/DSL/Search/TemplateSectionSortFieldDescriptor.cs
 delete mode 100644 src/Nest/Domain/Template/ITemplateSection.cs
 delete mode 100644 src/Nest/Domain/Template/TemplateBuilder.cs
 delete mode 100644 src/Nest/Resolvers/Converters/TemplateSectionConverter.cs

diff --git a/src/Nest/DSL/Query/TemplateSectionQueryContainer.cs b/src/Nest/DSL/Query/TemplateSectionQueryContainer.cs
deleted file mode 100644
index 87e017f3c28..00000000000
--- a/src/Nest/DSL/Query/TemplateSectionQueryContainer.cs
+++ /dev/null
@@ -1,24 +0,0 @@
-using Nest.Resolvers.Converters;
-using Newtonsoft.Json;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Nest
-{
-	[JsonConverter(typeof(TemplateSectionConverter))]
-	public class TemplateSectionQueryContainer : QueryContainer, ITemplateSection
-	{
-		private readonly QueryContainer _queryContainer;
-		private readonly string _variable;
-		object ITemplateSection.Instance { get { return _queryContainer; } }
-		string ITemplateSection.Variable { get { return _variable; } }
-
-		public TemplateSectionQueryContainer(string variable, QueryContainer o)
-		{
-			_variable = variable;
-			_queryContainer = o;
-		}
-	}
-}
diff --git a/src/Nest/DSL/Search/TemplateSectionSortFieldDescriptor.cs b/src/Nest/DSL/Search/TemplateSectionSortFieldDescriptor.cs
deleted file mode 100644
index 9c936b0a21c..00000000000
--- a/src/Nest/DSL/Search/TemplateSectionSortFieldDescriptor.cs
+++ /dev/null
@@ -1,23 +0,0 @@
-using Nest.Resolvers.Converters;
-using Newtonsoft.Json;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Nest
-{
-	[JsonConverter(typeof(TemplateSectionConverter))]
-	public class TemplateSectionSortFieldDescriptor : SortFieldDescriptor<object>, ITemplateSection
-	{
-		private readonly IFieldSort _queryContainer;
-		private readonly string _variable;
-		object ITemplateSection.Instance { get { return _queryContainer; } }
-		string ITemplateSection.Variable { get { return _variable; } }
-		public TemplateSectionSortFieldDescriptor(string variable, IFieldSort o)
-		{
-			_variable = variable;
-			_queryContainer = o;
-		}
-	}
-}
diff --git a/src/Nest/Domain/Template/ITemplateSection.cs b/src/Nest/Domain/Template/ITemplateSection.cs
deleted file mode 100644
index bbf69359fd2..00000000000
--- a/src/Nest/Domain/Template/ITemplateSection.cs
+++ /dev/null
@@ -1,13 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Nest
-{
-	public interface ITemplateSection
-	{
-		object Instance { get; }
-		string Variable { get; }
-	}
-}
diff --git a/src/Nest/Domain/Template/TemplateBuilder.cs b/src/Nest/Domain/Template/TemplateBuilder.cs
deleted file mode 100644
index acb78966d94..00000000000
--- a/src/Nest/Domain/Template/TemplateBuilder.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Nest
-{
-	public static class TemplateBuilder
-	{
-		public static Func<SortFieldDescriptor<T>, IFieldSort> Section<T>(string variable, Func<SortFieldDescriptor<T>, IFieldSort> s)
-			where T : class
-		{
-			return new Func<SortFieldDescriptor<T>, IFieldSort>(inner => new TemplateSectionSortFieldDescriptor(variable, s(inner)));
-		}
-
-		public static QueryContainer Section(string variable, QueryContainer o)
-		{
-			return new TemplateSectionQueryContainer(variable, o);
-		}
-
-		public static string Variable(string name, string defaultValue = null)
-		{
-			if (!string.IsNullOrWhiteSpace(defaultValue))
-				return "{{" + name + "}}{{^" + name + "}}" + defaultValue + "{{/" + name + "}}";
-			return "{{" + name + "}}";
-		}
-
-		public static IEnumerable<string> Array(string name)
-		{
-			return new[] {
-				"{{#"+name+"}",
-				"{{.}}",
-				"{{/" + name + "}"
-			};
-		}
-	}
-}
diff --git a/src/Nest/Nest.csproj b/src/Nest/Nest.csproj
index fe15740a620..6461d010465 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -197,14 +197,10 @@
     <Compile Include="Domain\Stats\PercolateStats.cs" />
     <Compile Include="Domain\Stats\PluginStats.cs" />
     <Compile Include="Domain\Stats\SegmentsStats.cs" />
-    <Compile Include="Domain\Template\ITemplateSection.cs" />
-    <Compile Include="Domain\Template\TemplateBuilder.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\Query\TemplateSectionQueryContainer.cs" />
-    <Compile Include="DSL\Search\TemplateSectionSortFieldDescriptor.cs" />
     <Compile Include="DSL\CatIndicesDescriptor.cs" />
     <Compile Include="DSL\CatShardsDescriptor.cs" />
     <Compile Include="DSL\CatThreadPoolDescriptor.cs" />
@@ -904,7 +900,6 @@
     <Compile Include="Resolvers\Converters\DynamicMappingOptionConverter.cs" />
     <Compile Include="Resolvers\Converters\DictionaryKeysAreNotPropertyNamesJsonConverter.cs" />
     <Compile Include="Resolvers\Converters\IndexNameMarkerConverter.cs" />
-    <Compile Include="Resolvers\Converters\TemplateSectionConverter.cs" />
     <Compile Include="Resolvers\Converters\TokenFilterCollectionConverter.cs" />
     <Compile Include="Resolvers\Converters\TokenizerCollectionConverter.cs" />
     <Compile Include="Resolvers\Converters\TypeNameMarkerConverter.cs" />
diff --git a/src/Nest/Resolvers/Converters/TemplateSectionConverter.cs b/src/Nest/Resolvers/Converters/TemplateSectionConverter.cs
deleted file mode 100644
index 2f004ba5cb3..00000000000
--- a/src/Nest/Resolvers/Converters/TemplateSectionConverter.cs
+++ /dev/null
@@ -1,35 +0,0 @@
-using Newtonsoft.Json;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace Nest.Resolvers.Converters
-{
-	public class TemplateSectionConverter : JsonConverter
-	{
-		public override bool CanWrite { get { return true; } }
-
-		public override bool CanRead { get { return false; } }
-
-		public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
-		{
-			var v = value as ITemplateSection;
-			if (v == null) writer.WriteNull();
-
-			writer.WriteRaw("{{#" + v.Variable + "}}");
-			serializer.Serialize(writer, v.Instance);
-			writer.WriteRaw("{{/" + v.Variable + "}}");
-		}
-
-		public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
-		{
-			return null;
-		}
-
-		public override bool CanConvert(Type objectType)
-		{
-			return true;
-		}
-	}
-}