From ca112f9e357b5fc1e97e0993c8f9217f2f44d13c Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Thu, 27 Mar 2014 15:00:15 +0100
Subject: [PATCH 01/20] Updated tests for fields on covariant results

---
 build/build.fsx                                        | 2 +-
 src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs  | 3 ++-
 src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj       | 4 ++++
 src/Tests/Nest.Tests.Unit/Search/Fields/FieldsTests.cs | 1 +
 4 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/build/build.fsx b/build/build.fsx
index 56f9074e217..364e5c2b669 100644
--- a/build/build.fsx
+++ b/build/build.fsx
@@ -69,7 +69,7 @@ let nugetPack = fun name ->
     CreateDir nugetOutDir
     
     let dir = sprintf "%s/%s/" buildDir name
-    let version = "1.0.0-beta9"
+    let version = "1.0.0-c2"
     NuGetPack (fun p ->
       {p with 
         Version = version
diff --git a/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs b/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
index c7d3636b426..3954ceae0f3 100644
--- a/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
+++ b/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
@@ -101,7 +101,8 @@ internal bool SuccessOrKnownError
 			{
 				return this.Success ||
 					(this.HttpStatusCode.HasValue 
-					&& this.HttpStatusCode.Value != 503 
+					&& this.HttpStatusCode.Value != 503 //service unavailable needs to be retried
+					&& this.HttpStatusCode.Value != 502 //bad gateway needs to be retried 
 					&& ((this.HttpStatusCode.Value >= 400 && this.HttpStatusCode.Value < 599)));
 			}
 		}
diff --git a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
index ae810103a5a..9b77a5b41de 100644
--- a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
+++ b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
@@ -143,6 +143,7 @@
     <Compile Include="Internals\Inferno\HostNameWithPathTests.cs" />
     <Compile Include="Internals\Inferno\MapTypeNamesTests.cs" />
     <Compile Include="Internals\Serialize\OptOutTests.cs" />
+    <Compile Include="Search\Fields\FieldsTests.cs" />
     <Compile Include="Search\Filter\Modes\ConditionlessFilterJson.cs" />
     <Compile Include="Search\Filter\Modes\FilterModesTests.cs" />
     <Compile Include="Search\Filter\Singles\TermsLookupFilterJson.cs" />
@@ -407,6 +408,9 @@
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
     <None Include="packages.config" />
+    <None Include="Search\Fields\FixedCovariantSearchResult.json">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
     <None Include="Search\Filter\BoolFilterMerges\ShouldNotJoinTermIntoMustStrictFilter.json">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
diff --git a/src/Tests/Nest.Tests.Unit/Search/Fields/FieldsTests.cs b/src/Tests/Nest.Tests.Unit/Search/Fields/FieldsTests.cs
index bce21d4ec68..b1d2705b50b 100644
--- a/src/Tests/Nest.Tests.Unit/Search/Fields/FieldsTests.cs
+++ b/src/Tests/Nest.Tests.Unit/Search/Fields/FieldsTests.cs
@@ -51,6 +51,7 @@ public void FieldsSelectionIsCovariantAsWell()
 			var classAHit = classAHits.First();
 			classAHit.Fields.Should().NotBeNull();
 			var lang = classAHit.Fields.FieldValue<ClassA, string>(p => p.Lang).FirstOrDefault();
+			lang.Should().NotBeNullOrEmpty();
 
 			
 		}

From 9b2aa2e9e7edbc893dcf8baf3a45cd1a705fca13 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Fri, 28 Mar 2014 20:33:40 +0100
Subject: [PATCH 02/20] simplified IConnection and moved a lot of magic back
 into Transport

---
 .../ElasticsearchHttpClient.cs                | 216 ++++++------
 .../ThriftConnection.cs                       | 116 +++----
 .../Connection/ConnectionError.cs             |  36 +-
 .../Connection/HttpConnection.cs              | 324 +++++++-----------
 .../Connection/IConnection.cs                 |  31 +-
 .../Connection/InMemoryConnection.cs          |  23 +-
 src/Elasticsearch.Net/Connection/Transport.cs | 276 +++++++++++++--
 .../Domain/ElasticsearchResponse.cs           | 111 +++---
 src/Elasticsearch.sln                         |   1 +
 .../Domain/Responses/IndexExistsResponse.cs   |   4 +-
 src/Profiling/Profiling.Indexing/Tester.cs    |   2 +-
 .../YamlTestsBase.cs                          |  17 +-
 .../Connection/ConcurrencyTests.cs            |   5 +-
 .../Connection/RetryTests.cs                  |   5 +-
 .../Connection/SniffingConnectionPoolTests.cs |   2 +-
 .../StaticConnectionPoolRetryTests.cs         |  34 +-
 .../Stubs/FakeCalls.cs                        |  11 +-
 .../Stubs/FakeResponse.cs                     |  13 +-
 .../Stubs/NoopConnection.cs                   |  57 +--
 .../Connection/Thrift/ThiftBugReportTests.cs  |   3 +-
 .../Nest.Tests.Integration/ConnectionTests.cs |   4 +-
 .../Core/Get/GetFullTests.cs                  |   2 +-
 .../Core/Get/GetMultiTests.cs                 |   2 +-
 .../Nest.Tests.Integration/Core/IndexTests.cs |  36 +-
 .../ElasticsearchConfiguration.cs             |   1 +
 .../Facet/BaseFacetTestFixture.cs             |   2 +-
 .../Indices/IndicesTests.cs                   |   2 +-
 .../Indices/OpenCloseTests.cs                 |   5 +-
 .../IntegrationTests.cs                       |   1 +
 .../RawCalls/ReturnTypesTest.cs               |  20 +-
 .../Search/QueryResponseMapperTests.cs        |   7 +-
 .../Warmers/WarmersTests.cs                   |   2 +-
 .../Core/Validate/ValidateRequestTests.cs     |   2 +-
 .../Search/SearchOptions/SearchOptionTests.cs |   4 +-
 34 files changed, 733 insertions(+), 644 deletions(-)

diff --git a/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs b/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs
index fe7fbb5bd7b..7c2b03f6899 100644
--- a/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs
+++ b/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs
@@ -9,121 +9,119 @@
 
 namespace Elasticsearch.Net.Connection.HttpClient
 {
-    public class ElasticsearchHttpClient : IConnection
-    {
-	    private IConnectionConfigurationValues _settings;
-
-	    public ElasticsearchHttpClient(IConnectionConfigurationValues settings)
-	    {
-		    _settings = settings;
-	    }
-
-	    public ElasticsearchResponse<T> DoSyncRequest<T>(string method, Uri uri, byte[] data = null)
-	    {
-		    var client = new System.Net.Http.HttpClient();
-		    HttpResponseMessage response = null;
-		    HttpContent content = null;
+	public class ElasticsearchHttpClient : IConnection
+	{
+		private IConnectionConfigurationValues _settings;
+
+		public ElasticsearchHttpClient(IConnectionConfigurationValues settings)
+		{
+			_settings = settings;
+		}
+
+		public ElasticsearchResponse<Stream> DoSyncRequest<T>(string method, Uri uri, byte[] data = null)
+		{
+			var client = new System.Net.Http.HttpClient();
+			HttpResponseMessage response = null;
+			HttpContent content = null;
 			if (data != null)
 				content = new ByteArrayContent(data);
-		    switch (method.ToLower())
-		    {
-			    case "head":
-					response = client.SendAsync(new HttpRequestMessage(HttpMethod.Head, uri) ).Result;
-				    break;
-			    case "delete":
+			switch (method.ToLower())
+			{
+				case "head":
+					response = client.SendAsync(new HttpRequestMessage(HttpMethod.Head, uri)).Result;
+					break;
+				case "delete":
 					response = client.SendAsync(new HttpRequestMessage(HttpMethod.Delete, uri) { Content = content }).Result;
-				    break;
-			    case "put":
+					break;
+				case "put":
 					response = client.PutAsync(uri, content).Result;
-				    break;
-			    case "post":
+					break;
+				case "post":
 					response = client.PostAsync(uri, content).Result;
-				    break;
-			    case "get":
+					break;
+				case "get":
 					response = client.GetAsync(uri).Result;
-				    break;
-		    }
+					break;
+			}
 			if (response == null)
-				return ElasticsearchResponse<T>.CreateError(_settings, null, method, uri.ToString(), data);
+				return ElasticsearchResponse<Stream>.CreateError(_settings, null, method, uri.ToString(), data);
 			using (var result = response.Content.ReadAsStreamAsync().Result)
-				return ElasticsearchResponse<T>.Create(this._settings, (int)response.StatusCode, method, uri.ToString(), data, result);
-	    }
-
-
-
-	    public Task<ElasticsearchResponse<T>> Get<T>(Uri uri, object deserializeState = null)
-	    {
-		    throw new NotImplementedException();
-	    }
-
-	    public ElasticsearchResponse<T> GetSync<T>(Uri uri, object deserializeState = null)
-	    {
-		    return this.DoSyncRequest<T>("get", uri);
-	    }
-
-	    public Task<ElasticsearchResponse<T>> Head<T>(Uri uri, object deserializeState = null)
-	    {
-		    throw new NotImplementedException();
-	    }
-
-	    public ElasticsearchResponse<T> HeadSync<T>(Uri uri, object deserializeState = null)
-	    {
-		    return this.DoSyncRequest<T>("head", uri);
-		    throw new NotImplementedException();
-	    }
-
-	    public Task<ElasticsearchResponse<T>> Post<T>(Uri uri, byte[] data, object deserializeState = null)
-	    {
-		    throw new NotImplementedException();
-	    }
-
-	    public ElasticsearchResponse<T> PostSync<T>(Uri uri, byte[] data, object deserializeState = null)
-	    {
-		    return this.DoSyncRequest<T>("post", uri, data);
-		    throw new NotImplementedException();
-	    }
-
-	    public Task<ElasticsearchResponse<T>> Put<T>(Uri uri, byte[] data, object deserializeState = null)
-	    {
-		    throw new NotImplementedException();
-	    }
-
-	    public ElasticsearchResponse<T> PutSync<T>(Uri uri, byte[] data, object deserializeState = null)
-	    {
-		    return this.DoSyncRequest<T>("put", uri, data);
-		    throw new NotImplementedException();
-	    }
-
-	    public Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, object deserializeState = null)
-	    {
-		    throw new NotImplementedException();
-	    }
-
-	    public ElasticsearchResponse<T> DeleteSync<T>(Uri uri, object deserializeState = null)
-	    {
-		    return this.DoSyncRequest<T>("delete", uri);
-		    throw new NotImplementedException();
-	    }
-
-	    public Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, byte[] data, object deserializeState = null)
-	    {
-		    throw new NotImplementedException();
-	    }
-
-	    public ElasticsearchResponse<T> DeleteSync<T>(Uri uri, byte[] data, object deserializeState = null)
-	    {
-		    return this.DoSyncRequest<T>("delete", uri, data);
-		    throw new NotImplementedException();
-	    }
-
-	    public bool Ping(Uri uri)
-	    {
-		    throw new NotImplementedException();
-	    }
-
-	    public IList<Uri> Sniff(Uri uri)
-	    {
-		    throw new NotImplementedException();
-	    }
-    }
+			{
+				var cs = ElasticsearchResponse<Stream>.Create(this._settings, (int)response.StatusCode, method, uri.ToString(), data, result);
+				return cs;
+			}
+		}
+
+
+
+		public Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		{
+			throw new NotImplementedException();
+		}
+
+		public bool Ping(Uri uri)
+		{
+			throw new NotImplementedException();
+		}
+
+		public IList<Uri> Sniff(Uri uri)
+		{
+			throw new NotImplementedException();
+		}
+	}
 }
diff --git a/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs b/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs
index 6b1ea02dd8a..cedecdbdf7d 100644
--- a/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs
+++ b/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs
@@ -45,7 +45,7 @@ public ThriftConnection(IConnectionConfigurationValues connectionSettings)
 
 		#region IConnection Members
 
-		public Task<ElasticsearchResponse<T>> Get<T>(Uri uri, object deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.GET;
@@ -53,13 +53,13 @@ public Task<ElasticsearchResponse<T>> Get<T>(Uri uri, object deserializationStat
 
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return Task.Factory.StartNew<ElasticsearchResponse<T>>(() =>
+			return Task.Factory.StartNew<ElasticsearchResponse<Stream>>(() =>
 			{
-				return this.Execute<T>(restRequest, deserializationState);
+				return this.Execute(restRequest, deserializationState);
 			});
 		}
 	
-		public Task<ElasticsearchResponse<T>> Head<T>(Uri uri, object deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.HEAD;
@@ -67,13 +67,13 @@ public Task<ElasticsearchResponse<T>> Head<T>(Uri uri, object deserializationSta
 
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return Task.Factory.StartNew<ElasticsearchResponse<T>>(()=> 
+			return Task.Factory.StartNew<ElasticsearchResponse<Stream>>(()=> 
 			{
-				return this.Execute<T>(restRequest, deserializationState);
+				return this.Execute(restRequest, deserializationState);
 			});
 		}
 
-		public ElasticsearchResponse<T> GetSync<T>(Uri uri, object deserializationState = null)
+		public ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.GET;
@@ -81,10 +81,10 @@ public ElasticsearchResponse<T> GetSync<T>(Uri uri, object deserializationState
 
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return this.Execute<T>(restRequest, deserializationState);
+			return this.Execute(restRequest, deserializationState);
 		}
 
-		public ElasticsearchResponse<T> HeadSync<T>(Uri uri, object deserializationState = null)
+		public ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.HEAD;
@@ -92,10 +92,10 @@ public ElasticsearchResponse<T> HeadSync<T>(Uri uri, object deserializationState
 
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return this.Execute<T>(restRequest, deserializationState);
+			return this.Execute(restRequest, deserializationState);
 		}
 
-		public Task<ElasticsearchResponse<T>> Post<T>(Uri uri, byte[] data, object deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.POST;
@@ -104,12 +104,12 @@ public Task<ElasticsearchResponse<T>> Post<T>(Uri uri, byte[] data, object deser
 			restRequest.Body = data;
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return Task.Factory.StartNew<ElasticsearchResponse<T>>(() =>
+			return Task.Factory.StartNew<ElasticsearchResponse<Stream>>(() =>
 			{
-				return this.Execute<T>(restRequest, deserializationState);
+				return this.Execute(restRequest, deserializationState);
 			});
 		}
-		public Task<ElasticsearchResponse<T>> Put<T>(Uri uri, byte[] data, object deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.PUT;
@@ -118,12 +118,12 @@ public Task<ElasticsearchResponse<T>> Put<T>(Uri uri, byte[] data, object deseri
 			restRequest.Body = data;
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return Task.Factory.StartNew<ElasticsearchResponse<T>>(() =>
+			return Task.Factory.StartNew<ElasticsearchResponse<Stream>>(() =>
 			{
-				return this.Execute<T>(restRequest, deserializationState);
+				return this.Execute(restRequest, deserializationState);
 			});
 		}
-		public Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, byte[] data, object deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.DELETE;
@@ -132,13 +132,13 @@ public Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, byte[] data, object des
 			restRequest.Body = data;
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return Task.Factory.StartNew<ElasticsearchResponse<T>>(() =>
+			return Task.Factory.StartNew<ElasticsearchResponse<Stream>>(() =>
 			{
-				return this.Execute<T>(restRequest, deserializationState);
+				return this.Execute(restRequest, deserializationState);
 			});
 		}
 
-		public ElasticsearchResponse<T> PostSync<T>(Uri uri, byte[] data, object deserializationState = null)
+		public ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.POST;
@@ -147,9 +147,9 @@ public ElasticsearchResponse<T> PostSync<T>(Uri uri, byte[] data, object deseria
 			restRequest.Body = data;
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return this.Execute<T>(restRequest, deserializationState);
+			return this.Execute(restRequest, deserializationState);
 		}
-		public ElasticsearchResponse<T> PutSync<T>(Uri uri, byte[] data, object deserializationState = null)
+		public ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.PUT;
@@ -158,9 +158,9 @@ public ElasticsearchResponse<T> PutSync<T>(Uri uri, byte[] data, object deserial
 			restRequest.Body = data;
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return this.Execute<T>(restRequest, deserializationState);
+			return this.Execute(restRequest, deserializationState);
 		}
-		public Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, object deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.DELETE;
@@ -168,13 +168,13 @@ public Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, object deserializationS
 
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return Task.Factory.StartNew<ElasticsearchResponse<T>>(() =>
+			return Task.Factory.StartNew<ElasticsearchResponse<Stream>>(() =>
 			{
-				return this.Execute<T>(restRequest, deserializationState);
+				return this.Execute(restRequest, deserializationState);
 			});
 		}
 
-		public ElasticsearchResponse<T> DeleteSync<T>(Uri uri, object deserializationState = null)
+		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.DELETE;
@@ -182,9 +182,9 @@ public ElasticsearchResponse<T> DeleteSync<T>(Uri uri, object deserializationSta
 
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return this.Execute<T>(restRequest, deserializationState);
+			return this.Execute(restRequest, deserializationState);
 		}
-		public ElasticsearchResponse<T> DeleteSync<T>(Uri uri, byte[] data, object deserializationState = null)
+		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.DELETE;
@@ -193,7 +193,7 @@ public ElasticsearchResponse<T> DeleteSync<T>(Uri uri, byte[] data, object deser
 			restRequest.Body = data;
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			return this.Execute<T>(restRequest, deserializationState);
+			return this.Execute(restRequest, deserializationState);
 		}
 
 		public bool Ping(Uri uri)
@@ -204,7 +204,7 @@ public bool Ping(Uri uri)
 			
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			var r  = this.Execute<object>(restRequest, null); //TODO VoidResponse
+			var r  = this.Execute(restRequest, null); //TODO VoidResponse
 			return r.Success;
 		}
 
@@ -216,11 +216,8 @@ public IList<Uri> Sniff(Uri uri)
 
 			restRequest.Headers = new Dictionary<string, string>();
 			restRequest.Headers.Add("Content-Type", "application/json");
-			var r  = this.Execute<byte[]>(restRequest, null);
-			using (var memoryStream = new MemoryStream(r.Response))
-			{
-				return Sniffer.FromStream(r, memoryStream, this._connectionSettings.Serializer);
-			}
+			var r  = this.Execute(restRequest, null);
+			return Sniffer.FromStream(r, r.Response, this._connectionSettings.Serializer);
 		}
 
 		#endregion
@@ -270,7 +267,7 @@ protected virtual void Dispose(bool disposing)
 
 
 
-		private ElasticsearchResponse<T> Execute<T>(RestRequest restRequest, object deserializationState)
+		private ElasticsearchResponse<Stream> Execute(RestRequest restRequest, object deserializationState)
 		{
 			//RestResponse result = GetClient().execute(restRequest);
 			//
@@ -280,7 +277,7 @@ private ElasticsearchResponse<T> Execute<T>(RestRequest restRequest, object dese
 			if (!this._resourceLock.WaitOne(this._timeout))
 			{
 				var m = "Could not start the thrift operation before the timeout of " + this._timeout + "ms completed while waiting for the semaphore";
-				return ElasticsearchResponse<T>.CreateError(this._connectionSettings, new TimeoutException(m), method, path, requestData);
+				return ElasticsearchResponse<Stream>.CreateError(this._connectionSettings, new TimeoutException(m), method, path, requestData);
 			}
 			try
 			{
@@ -288,7 +285,7 @@ private ElasticsearchResponse<T> Execute<T>(RestRequest restRequest, object dese
 				if (!this._clients.TryDequeue(out client))
 				{
 					var m = string.Format("Could dequeue a thrift client from internal socket pool of size {0}", this._poolSize);
-					var status = ElasticsearchResponse<T>.CreateError(this._connectionSettings, new Exception(m), method, path, requestData);
+					var status = ElasticsearchResponse<Stream>.CreateError(this._connectionSettings, new Exception(m), method, path, requestData);
 					return status;
 				}
 				try
@@ -299,34 +296,17 @@ private ElasticsearchResponse<T> Execute<T>(RestRequest restRequest, object dese
 					var result = client.execute(restRequest);
 					if (result.Status == Status.OK || result.Status == Status.CREATED || result.Status == Status.ACCEPTED)
 					{
-						var response = ElasticsearchResponse<T>.Create(this._connectionSettings, (int)result.Status, method, path, requestData);
-						if (typeof(T) == typeof(VoidResponse))
-							return response;
-						using (var ms = new MemoryStream(result.Body))
-						{
-							if (this._connectionSettings.KeepRawResponse) 
-							{
-								response.ResponseRaw = result.Body;
-							}
-							if (typeof(T) == typeof(string))
-								this.SetStringResult(response as ElasticsearchResponse<string>, result.Body);
-							else if (typeof(T) == typeof(byte[]))
-								this.SetByteResult(response as ElasticsearchResponse<byte[]>, result.Body);
-							else 
-								response.Response = this._connectionSettings.Serializer.Deserialize<T>(response, ms, deserializationState);
-							return response;
-						};
+						var response = ElasticsearchResponse<Stream>.Create(this._connectionSettings, (int)result.Status, method, path, requestData);
+						response.Response = new MemoryStream(result.Body);
+						return response;
 					}
 					else
 					{
-						var connectionException = new ConnectionException((int)result.Status);
-						return ElasticsearchResponse<T>.CreateError(this._connectionSettings, connectionException, method, path, requestData);
+						var response = ElasticsearchResponse<Stream>.Create(this._connectionSettings, (int)result.Status, method, path, requestData);
+						response.Response = new MemoryStream(result.Body);
+						return response;
 					}
 				}
-				catch
-				{
-					throw;
-				}
 				finally
 				{
 					//make sure we make the client available again.
@@ -336,7 +316,7 @@ private ElasticsearchResponse<T> Execute<T>(RestRequest restRequest, object dese
 			}
 			catch (Exception e)
 			{
-				return ElasticsearchResponse<T>.CreateError(this._connectionSettings, e, method, path, requestData);
+				return ElasticsearchResponse<Stream>.CreateError(this._connectionSettings, e, method, path, requestData);
 			}
 			finally
 			{
@@ -344,16 +324,6 @@ private ElasticsearchResponse<T> Execute<T>(RestRequest restRequest, object dese
 			}
 		}
 
-		private void SetByteResult(ElasticsearchResponse<byte[]> elasticsearchResponse, byte[] body)
-		{
-			elasticsearchResponse.Response = body;
-		}
-
-		private void SetStringResult(ElasticsearchResponse<string> elasticsearchResponse, byte[] body)
-		{
-			elasticsearchResponse.Response = body.Utf8String();
-		}
-
 		public string DecodeStr(byte[] bytes)
 		{
 			if (bytes != null && bytes.Length > 0)
diff --git a/src/Elasticsearch.Net/Connection/ConnectionError.cs b/src/Elasticsearch.Net/Connection/ConnectionError.cs
index 8d7b689a82b..15ce9b9fe76 100644
--- a/src/Elasticsearch.Net/Connection/ConnectionError.cs
+++ b/src/Elasticsearch.Net/Connection/ConnectionError.cs
@@ -7,31 +7,17 @@
 
 namespace Elasticsearch.Net.Connection
 {
-	public enum ConnectionErrorType
-	{
-		/// <summary>
-		/// The error was due to an uncaught exception in the client code
-		/// </summary>
-		Uncaught,
-		/// <summary>
-		/// The error was due to an error thrown by Elasticsearch
-		/// </summary>
-		Server,
-	}
 
 	public class ConnectionError
 	{
-		public ConnectionErrorType Type { get; set; }
 		public HttpStatusCode? HttpStatusCode { get; set; }
 		public string ExceptionMessage { get; set; }
 		public Exception OriginalException { get; set; }
-		public byte[] ResponseReadFromWebException { get; set; }
 
 		public ConnectionError(Exception e)
 		{
 			this.OriginalException = e;
 			this.ExceptionMessage = e.Message;
-			this.Type = ConnectionErrorType.Uncaught;
 			var webException = e as WebException;
 			if (webException == null)
 			{
@@ -41,29 +27,13 @@ public ConnectionError(Exception e)
 				this.HttpStatusCode = (HttpStatusCode)connectionException.HttpStatusCode;
 				return;
 			}
-			this.Type = ConnectionErrorType.Server;
-			var response = (HttpWebResponse)webException.Response;
-			this.SetWebResponseData(response);
+			//var response = (HttpWebResponse)webException.Response;
+			//this.SetWebResponseData(response);
 		}
 
 		private void SetWebResponseData(HttpWebResponse response)
 		{
-			if (response == null)
-				return;
-
-			this.HttpStatusCode = response.StatusCode;
-			try
-			{
-				using (var responseStream = response.GetResponseStream())
-				using (var memoryStream = new MemoryStream())
-				{
-					responseStream.CopyTo(memoryStream);
-					this.ResponseReadFromWebException = memoryStream.ToArray();
-				}
-			}
-			finally 
-			{ 
-			}
+			
 		}
 		
 	}
diff --git a/src/Elasticsearch.Net/Connection/HttpConnection.cs b/src/Elasticsearch.Net/Connection/HttpConnection.cs
index 879232e7d1b..d29b1c712d8 100644
--- a/src/Elasticsearch.Net/Connection/HttpConnection.cs
+++ b/src/Elasticsearch.Net/Connection/HttpConnection.cs
@@ -42,33 +42,44 @@ public HttpConnection(IConnectionConfigurationValues settings)
 			this._enableTrace = settings.TraceEnabled;
 		}
 
-		public virtual ElasticsearchResponse<T> GetSync<T>(Uri uri, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			return this.HeaderOnlyRequest<T>(uri, "GET", deserializationState);
+			return this.HeaderOnlyRequest(uri, "GET", requestSpecificConfig);
 		}
-		public virtual ElasticsearchResponse<T> HeadSync<T>(Uri uri, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			return this.HeaderOnlyRequest<T>(uri, "HEAD", deserializationState);
+			return this.HeaderOnlyRequest(uri, "HEAD", requestSpecificConfig);
 		}
 
-		public virtual ElasticsearchResponse<T> PostSync<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			return this.BodyRequest<T>(uri, data, "POST", deserializationState);
+			return this.BodyRequest(uri, data, "POST", requestSpecificConfig);
 		}
-		public virtual ElasticsearchResponse<T> PutSync<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			return this.BodyRequest<T>(uri, data, "PUT", deserializationState);
+			return this.BodyRequest(uri, data, "PUT", requestSpecificConfig);
 		}
-		public virtual ElasticsearchResponse<T> DeleteSync<T>(Uri uri, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			return this.HeaderOnlyRequest<T>(uri, "DELETE", deserializationState);
+			return this.HeaderOnlyRequest(uri, "DELETE", requestSpecificConfig);
 		}
-		public virtual ElasticsearchResponse<T> DeleteSync<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			return this.BodyRequest<T>(uri, data, "DELETE", deserializationState);
+			return this.BodyRequest(uri, data, "DELETE", requestSpecificConfig);
+		}
+
+		private ElasticsearchResponse<Stream> HeaderOnlyRequest(Uri uri, string method, IConnectionConfigurationOverrides requestSpecificConfig)
+		{
+			var r = this.CreateHttpWebRequest(uri, method);
+			return this.DoSynchronousRequest(r, requestSpecificConfig: requestSpecificConfig);
+		}
+
+		private ElasticsearchResponse<Stream> BodyRequest(Uri uri, byte[] data, string method, IConnectionConfigurationOverrides requestSpecificConfig)
+		{
+			var r = this.CreateHttpWebRequest(uri, method);
+			return this.DoSynchronousRequest(r, data, requestSpecificConfig);
 		}
 
-		
 		public virtual bool Ping(Uri uri)
 		{
 			var request = this.CreateHttpWebRequest(uri, "HEAD");
@@ -96,37 +107,37 @@ public virtual IList<Uri> Sniff(Uri uri)
 			}
 		}
 
-		public virtual Task<ElasticsearchResponse<T>> Get<T>(Uri uri, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "GET");
-			return this.DoAsyncRequest<T>(r, deserializationState: deserializationState);
+			return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
-		public virtual Task<ElasticsearchResponse<T>> Head<T>(Uri uri, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "HEAD");
-			return this.DoAsyncRequest<T>(r, deserializationState: deserializationState);
+			return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
-		public virtual Task<ElasticsearchResponse<T>> Post<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "POST");
-			return this.DoAsyncRequest<T>(r, data, deserializationState: deserializationState);
+			return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig);
 		}
 
-		public virtual Task<ElasticsearchResponse<T>> Put<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "PUT");
-			return this.DoAsyncRequest<T>(r, data, deserializationState: deserializationState);
+			return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig);
 		}
 
-		public virtual Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "DELETE");
-			return this.DoAsyncRequest<T>(r, data, deserializationState: deserializationState);
+			return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig);
 		}
-		public virtual Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "DELETE");
-			return this.DoAsyncRequest<T>(r, deserializationState: deserializationState);
+			return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
 
 		private static void ThreadTimeoutCallback(object state, bool timedOut)
@@ -141,17 +152,6 @@ private static void ThreadTimeoutCallback(object state, bool timedOut)
 			}
 		}
 
-		private ElasticsearchResponse<T> HeaderOnlyRequest<T>(Uri uri, string method, object deserializationState)
-		{
-			var r = this.CreateHttpWebRequest(uri, method);
-			return this.DoSynchronousRequest<T>(r, deserializationState: deserializationState);
-		}
-
-		private ElasticsearchResponse<T> BodyRequest<T>(Uri uri, byte[] data, string method, object deserializationState)
-		{
-			var r = this.CreateHttpWebRequest(uri, method);
-			return this.DoSynchronousRequest<T>(r, data, deserializationState);
-		}
 
 		protected virtual HttpWebRequest CreateHttpWebRequest(Uri uri, string method)
 		{
@@ -181,8 +181,8 @@ private void SetBasicAuthorizationIfNeeded(HttpWebRequest myReq)
 
 			//if (this._ConnectionSettings.UriSpecifiedBasicAuth)
 			//{
-				myReq.Headers["Authorization"] =
-					"Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(myReq.RequestUri.UserInfo));
+			myReq.Headers["Authorization"] =
+				"Basic " + Convert.ToBase64String(Encoding.UTF8.GetBytes(myReq.RequestUri.UserInfo));
 			//}
 		}
 
@@ -205,111 +205,75 @@ protected virtual HttpWebRequest CreateWebRequest(Uri uri, string method)
 			return myReq;
 		}
 
-		protected virtual ElasticsearchResponse<T> DoSynchronousRequest<T>(HttpWebRequest request, byte[] data = null, object deserializationState = null)
+		protected virtual ElasticsearchResponse<Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			var path = request.RequestUri.ToString();
 			var method = request.Method;
-			using (var tracer = new ElasticsearchResponseTracer<T>(this._ConnectionSettings.TraceEnabled))
+
+			if (data != null)
 			{
-				ElasticsearchResponse<T> cs = null;
-				if (data != null)
-				{
-					using (var r = request.GetRequestStream())
-					{
-						r.Write(data, 0, data.Length);
-					}
-				}
-				try
+				using (var r = request.GetRequestStream())
 				{
-					using (var response = (HttpWebResponse)request.GetResponse())
-					using (var responseStream = response.GetResponseStream())
-					return WebToElasticsearchResponse<T>(data, deserializationState, responseStream, response, method, path, tracer);
-				}
-				catch (WebException webException)
-				{
-					var httpEx = webException.Response as HttpWebResponse;
-					if (httpEx != null && httpEx.StatusCode == HttpStatusCode.NotFound)
-					{
-						cs = WebToElasticsearchResponse(data, deserializationState, httpEx.GetResponseStream(), httpEx, method, path, tracer);
-						cs.Error = new ConnectionError(webException);
-						return cs;
-
-					}
-					cs = ElasticsearchResponse<T>.CreateError(this._ConnectionSettings, webException, method, path, data);
-					tracer.SetResult(cs);
-					_ConnectionSettings.ConnectionStatusHandler(cs);
-					return cs;
+					r.Write(data, 0, data.Length);
 				}
 			}
-
+			try
+			{
+				//http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx
+				//Either the stream or the response object needs to be closed but not both although it won't
+				//throw any errors if both are closed atleast one of them has to be Closed.
+				//Since we expose the stream we let closing the stream determining when to close the connection
+				var response = (HttpWebResponse)request.GetResponse();
+				var responseStream = response.GetResponseStream();
+				return WebToElasticsearchResponse(data, responseStream, response, method, path);
+			}
+			catch (WebException webException)
+			{
+				return HandleWebException(data, webException, method, path);
+			}
 		}
 
-		private ElasticsearchResponse<T> WebToElasticsearchResponse<T>(byte[] data, object deserializationState,
-			Stream responseStream, HttpWebResponse response, string method, string path, ElasticsearchResponseTracer<T> tracer)
+		private ElasticsearchResponse<Stream> HandleWebException(byte[] data, WebException webException, string method, string path)
 		{
-			ElasticsearchResponse<T> cs = 
-				ElasticsearchResponse<T>.Create(this._ConnectionSettings, (int) response.StatusCode, method, path, data);
-			if (typeof(T) == typeof(VoidResponse))
-				return cs;
-			using (var memoryStream = new MemoryStream())
+			ElasticsearchResponse<Stream> cs = null;
+			var httpEx = webException.Response as HttpWebResponse;
+			if (httpEx != null)
 			{
-				Stream s = responseStream;
-				Type type = typeof(T);
-				if (_ConnectionSettings.KeepRawResponse || type == typeof(string) || type == typeof(byte[]))
-				{
-					responseStream.CopyTo(memoryStream);
-					//use memory stream for serialization instead
-					//our own serializers have special handling for memorystream
-					//that will prevent double reads
-					memoryStream.Position = 0;
-					s = memoryStream;
-					var bytes = memoryStream.ToArray();
-					if (typeof(T) == typeof(string))
-					{
-						this.SetStringResult(cs as ElasticsearchResponse<string>, bytes);
-						return cs;
-					}
-					if (typeof(T) == typeof(byte[]))
-					{
-						this.SetByteResult(cs as ElasticsearchResponse<byte[]>, bytes);
-						return cs;
-					}
-					cs.ResponseRaw = _ConnectionSettings.KeepRawResponse ? bytes: null;
-				}
-
-				var result = this._ConnectionSettings.Serializer.Deserialize<T>(cs, s, deserializationState);
-				cs.Response = result;
-				tracer.SetResult(cs);
+				cs = WebToElasticsearchResponse(data, httpEx.GetResponseStream(), httpEx, method, path);
 				return cs;
 			}
+			cs = ElasticsearchResponse<Stream>.CreateError(this._ConnectionSettings, webException, method, path, data);
+			return cs;
+		}
+
+		private ElasticsearchResponse<Stream> WebToElasticsearchResponse(byte[] data, Stream responseStream, HttpWebResponse response, string method, string path)
+		{
+			ElasticsearchResponse<Stream> cs = ElasticsearchResponse<Stream>.Create(this._ConnectionSettings, (int)response.StatusCode, method, path, data);
+			cs.Response = responseStream;
+			return cs;
 		}
 
-		protected virtual Task<ElasticsearchResponse<T>> DoAsyncRequest<T>(HttpWebRequest request, byte[] data = null, object deserializationState = null)
+		protected virtual Task<ElasticsearchResponse<Stream>> DoAsyncRequest(HttpWebRequest request, byte[] data = null, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			var tcs = new TaskCompletionSource<ElasticsearchResponse<T>>();
+			var tcs = new TaskCompletionSource<ElasticsearchResponse<Stream>>();
 			if (this._ConnectionSettings.MaximumAsyncConnections <= 0
 			  || this._ResourceLock == null)
-				return this.CreateIterateTask<T>(request, data, deserializationState, tcs);
+				return this.CreateIterateTask(request, data, requestSpecificConfig, tcs);
 
 			var timeout = this._ConnectionSettings.Timeout;
 			var path = request.RequestUri.ToString();
 			var method = request.Method;
 			if (!this._ResourceLock.WaitOne(timeout))
 			{
-				using (var tracer = new ElasticsearchResponseTracer<T>(this._ConnectionSettings.TraceEnabled))
-				{
-					var m = "Could not start the operation before the timeout of " + timeout +
-					  "ms completed while waiting for the semaphore";
-					var cs = ElasticsearchResponse<T>.CreateError(this._ConnectionSettings, new TimeoutException(m), method, path, data); 
-					tcs.SetResult(cs);
-					tracer.SetResult(cs);
-					_ConnectionSettings.ConnectionStatusHandler(cs);
-					return tcs.Task;
-				}
+				var m = "Could not start the operation before the timeout of " + timeout +
+				  "ms completed while waiting for the semaphore";
+				var cs = ElasticsearchResponse<Stream>.CreateError(this._ConnectionSettings, new TimeoutException(m), method, path, data);
+				tcs.SetResult(cs);
+				return tcs.Task;
 			}
 			try
 			{
-				return this.CreateIterateTask<T>(request, data, deserializationState, tcs);
+				return this.CreateIterateTask(request, data, requestSpecificConfig, tcs);
 			}
 			finally
 			{
@@ -317,113 +281,54 @@ protected virtual Task<ElasticsearchResponse<T>> DoAsyncRequest<T>(HttpWebReques
 			}
 		}
 
-		private Task<ElasticsearchResponse<T>> CreateIterateTask<T>(HttpWebRequest request, byte[] data, object deserializationState, TaskCompletionSource<ElasticsearchResponse<T>> tcs)
+		private Task<ElasticsearchResponse<Stream>> CreateIterateTask(HttpWebRequest request, byte[] data, object requestSpecificConfig, TaskCompletionSource<ElasticsearchResponse<Stream>> tcs)
 		{
-			this.Iterate<T>(request, data, this._AsyncSteps<T>(request, tcs, data, deserializationState), tcs);
+			this.Iterate(request, data, this._AsyncSteps(request, tcs, data, requestSpecificConfig), tcs);
 			return tcs.Task;
 		}
 
-		private IEnumerable<Task> _AsyncSteps<T>(HttpWebRequest request, TaskCompletionSource<ElasticsearchResponse<T>> tcs, byte[] data, object deserializationState)
+		private IEnumerable<Task> _AsyncSteps(HttpWebRequest request, TaskCompletionSource<ElasticsearchResponse<Stream>> tcs, byte[] data, object requestSpecificConfig)
 		{
-			using (var tracer = new ElasticsearchResponseTracer<T>(this._ConnectionSettings.TraceEnabled))
-			{
-				var timeout = this._ConnectionSettings.Timeout;
+			var timeout = this._ConnectionSettings.Timeout;
 
-				var state = new ConnectionState { Connection = request };
+			var state = new ConnectionState { Connection = request };
 
-				if (data != null)
-				{
-					var getRequestStream = Task.Factory.FromAsync<Stream>(request.BeginGetRequestStream, request.EndGetRequestStream, null);
-					//ThreadPool.RegisterWaitForSingleObject((getRequestStream as IAsyncResult).AsyncWaitHandle, ThreadTimeoutCallback, request, timeout, true);
-					yield return getRequestStream;
+			if (data != null)
+			{
+				var getRequestStream = Task.Factory.FromAsync<Stream>(request.BeginGetRequestStream, request.EndGetRequestStream, null);
+				//ThreadPool.RegisterWaitForSingleObject((getRequestStream as IAsyncResult).AsyncWaitHandle, ThreadTimeoutCallback, request, timeout, true);
+				yield return getRequestStream;
 
-					var requestStream = getRequestStream.Result;
-					try
-					{
-						var writeToRequestStream = Task.Factory.FromAsync(requestStream.BeginWrite, requestStream.EndWrite, data, 0, data.Length, state);
-						yield return writeToRequestStream;
-					}
-					finally
-					{
-						requestStream.Close();
-					}
+				var requestStream = getRequestStream.Result;
+				try
+				{
+					var writeToRequestStream = Task.Factory.FromAsync(requestStream.BeginWrite, requestStream.EndWrite, data, 0, data.Length, state);
+					yield return writeToRequestStream;
 				}
-
-				// Get the response
-				var getResponse = Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null);
-				//ThreadPool.RegisterWaitForSingleObject((getResponse as IAsyncResult).AsyncWaitHandle, ThreadTimeoutCallback, request, timeout, true);
-				yield return getResponse;
-
-				var path = request.RequestUri.ToString();
-				var method = request.Method;
-
-				// Get the response stream
-				using (var response = (HttpWebResponse)getResponse.Result)
-				using (var responseStream = response.GetResponseStream())
-				using (var memoryStream = new MemoryStream())
+				finally
 				{
-					Stream s = responseStream;
-					var cs = ElasticsearchResponse<T>.Create(this._ConnectionSettings, (int) response.StatusCode, method, path, data);	
-					if (typeof(T) == typeof(VoidResponse))
-					{
-						SetReturnOnAsycActors(tcs, cs, tracer);
-						yield break;
-					}
-					Type type = typeof(T);
-					if (_ConnectionSettings.KeepRawResponse || type == typeof(string) || type == typeof(byte[]))
-					{
-						// Copy all data from the response stream
-						var buffer = new byte[BUFFER_SIZE];
-						while (responseStream != null)
-						{
-							var read = Task<int>.Factory.FromAsync(responseStream.BeginRead, responseStream.EndRead, buffer, 0, BUFFER_SIZE, null);
-							yield return read;
-							if (read.Result == 0) break;
-							memoryStream.Write(buffer, 0, read.Result);
-						}
-						memoryStream.Position = 0;
-						s = memoryStream;
-						var bytes = memoryStream.ToArray();
-						if (typeof(T) == typeof(string))
-						{
-							this.SetStringResult(cs as ElasticsearchResponse<string>, bytes);
-							SetReturnOnAsycActors(tcs, cs, tracer);
-							yield break;
-						}
-						if (typeof(T) == typeof(byte[]))
-						{
-							this.SetByteResult(cs as ElasticsearchResponse<byte[]>, bytes);
-							SetReturnOnAsycActors(tcs, cs, tracer);
-							yield break;
-						}
-						cs.ResponseRaw = _ConnectionSettings.KeepRawResponse ? bytes : null;
-					}
-					var t = this._ConnectionSettings.Serializer.DeserializeAsync<T>(cs, s, deserializationState);
-					yield return t;
-					cs.Response = t.Result;
-					SetReturnOnAsycActors(tcs, cs, tracer);
+					requestStream.Close();
 				}
 			}
-		}
 
-		private void SetReturnOnAsycActors<T>(TaskCompletionSource<ElasticsearchResponse<T>> tcs, ElasticsearchResponse<T> cs,
-			ElasticsearchResponseTracer<T> tracer)
-		{
-			tcs.TrySetResult(cs);
-			tracer.SetResult(cs);
-			_ConnectionSettings.ConnectionStatusHandler(cs);
-		}
+			// Get the response
+			var getResponse = Task.Factory.FromAsync<WebResponse>(request.BeginGetResponse, request.EndGetResponse, null);
+			//ThreadPool.RegisterWaitForSingleObject((getResponse as IAsyncResult).AsyncWaitHandle, ThreadTimeoutCallback, request, timeout, true);
+			yield return getResponse;
 
-		public void SetStringResult(ElasticsearchResponse<string> response, byte[] rawResponse)
-		{
-			response.Response = rawResponse.Utf8String();
-		}
-	
-		public void SetByteResult(ElasticsearchResponse<byte[]> response, byte[] rawResponse)
-		{
-			response.Response = rawResponse;
-		}
+			var path = request.RequestUri.ToString();
+			var method = request.Method;
 
+			//http://msdn.microsoft.com/en-us/library/system.net.httpwebresponse.getresponsestream.aspx
+			//Either the stream or the response object needs to be closed but not both (although it won't)
+			//throw any errors if both are closed atleast one of them has to be Closed.
+			//Since we expose the stream we let closing the stream determining when to close the connection
+			var response = (HttpWebResponse)getResponse.Result;
+			var responseStream = response.GetResponseStream();
+			var cs = ElasticsearchResponse<Stream>.Create(this._ConnectionSettings, (int)response.StatusCode, method, path, data);
+			cs.Response = responseStream;
+			tcs.TrySetResult(cs);
+		}
 
 		public void Iterate<T>(HttpWebRequest request, byte[] data, IEnumerable<Task> asyncIterator, TaskCompletionSource<ElasticsearchResponse<T>> tcs)
 		{
@@ -442,6 +347,7 @@ public void Iterate<T>(HttpWebRequest request, byte[] data, IEnumerable<Task> as
 					{
 						var path = request.RequestUri.ToString();
 						var method = request.Method;
+
 						var response = ElasticsearchResponse<T>.CreateError(this._ConnectionSettings, exception, method, path, data);
 						tcs.SetResult(response);
 					}
@@ -458,7 +364,7 @@ public void Iterate<T>(HttpWebRequest request, byte[] data, IEnumerable<Task> as
 			recursiveBody(null);
 		}
 
-		
+
 
 	}
 }
diff --git a/src/Elasticsearch.Net/Connection/IConnection.cs b/src/Elasticsearch.Net/Connection/IConnection.cs
index ecf99a51e2d..e5f3fcd3a24 100644
--- a/src/Elasticsearch.Net/Connection/IConnection.cs
+++ b/src/Elasticsearch.Net/Connection/IConnection.cs
@@ -1,31 +1,38 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.IO;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
 
 namespace Elasticsearch.Net.Connection
 {
+	public interface IConnectionConfigurationOverrides
+	{
+		int RequestTimeout { get; }
+		int ConnectTimeout { get; }
+	}
+
 	public interface IConnection
 	{
 
-		Task<ElasticsearchResponse<T>> Get<T>(Uri uri, object deserializationState = null);
-		ElasticsearchResponse<T> GetSync<T>(Uri uri, object deserializationState = null);
+		Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<T>> Head<T>(Uri uri, object deserializationState = null);
-		ElasticsearchResponse<T> HeadSync<T>(Uri uri, object deserializationState = null);
+		Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<T>> Post<T>(Uri uri, byte[] data, object deserializationState = null);
-		ElasticsearchResponse<T> PostSync<T>(Uri uri, byte[] data, object deserializationState = null);
+		Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<T>> Put<T>(Uri uri, byte[] data, object deserializationState = null);
-		ElasticsearchResponse<T> PutSync<T>(Uri uri, byte[] data, object deserializationState = null);
+		Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, object deserializationState = null);
-		ElasticsearchResponse<T> DeleteSync<T>(Uri uri, object deserializationState = null);
+		Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, byte[] data, object deserializationState = null);
-		ElasticsearchResponse<T> DeleteSync<T>(Uri uri, byte[] data, object deserializationState = null);
+		Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
 
 		bool Ping(Uri uri);
 		IList<Uri> Sniff(Uri uri);
diff --git a/src/Elasticsearch.Net/Connection/InMemoryConnection.cs b/src/Elasticsearch.Net/Connection/InMemoryConnection.cs
index c9403f4de5e..59c51a9ad33 100644
--- a/src/Elasticsearch.Net/Connection/InMemoryConnection.cs
+++ b/src/Elasticsearch.Net/Connection/InMemoryConnection.cs
@@ -18,34 +18,31 @@ public InMemoryConnection(IConnectionConfigurationValues settings)
 		}
 
 		public InMemoryConnection(IConnectionConfigurationValues settings, string fixedResult)
-			: this (settings)
+			: this(settings)
 		{
 			_fixedResultBytes = Encoding.UTF8.GetBytes(fixedResult);
 		}
 
-		protected override ElasticsearchResponse<T> DoSynchronousRequest<T>(HttpWebRequest request, byte[] data = null, object deserializationState = null)
+		protected override ElasticsearchResponse<Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			return this.ReturnConnectionStatus<T>(request, data, deserializationState);
+			return this.ReturnConnectionStatus(request, data, requestSpecificConfig);
 		}
 
-		private ElasticsearchResponse<T> ReturnConnectionStatus<T>(HttpWebRequest request, byte[] data, object deserializationState = null)
+		private ElasticsearchResponse<Stream> ReturnConnectionStatus(HttpWebRequest request, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			var method = request.Method;
 			var path = request.RequestUri.ToString();
 
-			using (var ms = new MemoryStream(_fixedResultBytes))
-			{
-				var cs = ElasticsearchResponse<T>.Create(this._ConnectionSettings, 200, method, path, data, ms, deserializationState);
-				_ConnectionSettings.ConnectionStatusHandler(cs);
-				return cs;
-			}
+			var cs = ElasticsearchResponse<Stream>.Create(this._ConnectionSettings, 200, method, path, data);
+			cs.Response = new MemoryStream(_fixedResultBytes);
+			return cs;
 		}
 
-		protected override Task<ElasticsearchResponse<T>> DoAsyncRequest<T>(HttpWebRequest request, byte[] data = null, object deserializationState = null)
+		protected override Task<ElasticsearchResponse<Stream>> DoAsyncRequest(HttpWebRequest request, byte[] data = null, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			return Task.Factory.StartNew<ElasticsearchResponse<T>>(() =>
+			return Task.Factory.StartNew(() =>
 			{
-				var cs = this.ReturnConnectionStatus<T>(request, data, deserializationState);
+				var cs = this.ReturnConnectionStatus(request, data, requestSpecificConfig);
 				return cs;
 			});
 		}
diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index 13ee89a676b..4278b40a870 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -1,7 +1,10 @@
 using System;
 using System.Collections.Generic;
 using System.Collections.Specialized;
+using System.IO;
 using System.Linq;
+using System.Net;
+using System.Security.Cryptography;
 using System.Threading.Tasks;
 using Elasticsearch.Net.ConnectionPool;
 using Elasticsearch.Net.Exceptions;
@@ -26,20 +29,20 @@ public class Transport : ITransport
 
 		public Transport(
 			IConnectionConfigurationValues configurationValues,
-			IConnection connection, 
+			IConnection connection,
 			IElasticsearchSerializer serializer,
 			IDateTimeProvider dateTimeProvider = null
 			)
 		{
 			this._configurationValues = configurationValues;
-			this._connection = connection?? new HttpConnection(configurationValues);
+			this._connection = connection ?? new HttpConnection(configurationValues);
 			this._serializer = serializer ?? new ElasticsearchDefaultSerializer();
 			this._connectionPool = this._configurationValues.ConnectionPool;
 
 			//TODO: take the datetimeprovider from the connection pool?
 			this._dateTimeProvider = dateTimeProvider ?? new DateTimeProvider();
 
-				this._lastSniff = this._dateTimeProvider.Now();
+			this._lastSniff = this._dateTimeProvider.Now();
 		}
 
 		public void Sniff(bool fromStartup = false)
@@ -53,7 +56,7 @@ private void SniffIfInformationIsTooOld(int retried)
 			var sniffLifeSpan = this._configurationValues.SniffInformationLifeSpan;
 			var now = this._dateTimeProvider.Now();
 			if (retried == 0 && this._lastSniff.HasValue &&
-			    sniffLifeSpan.HasValue && sniffLifeSpan.Value < (now - this._lastSniff.Value))
+				sniffLifeSpan.HasValue && sniffLifeSpan.Value < (now - this._lastSniff.Value))
 				this.Sniff();
 		}
 
@@ -65,13 +68,12 @@ private int GetMaximumRetries()
 			return this._configurationValues.MaxRetries.GetValueOrDefault(this._connectionPool.MaxRetries);
 		}
 
-
 		public ElasticsearchResponse<T> DoRequest<T>(
 			string method,
 			string path,
 			object data = null,
 			NameValueCollection queryString = null,
-			object deserializationState= null,
+			object deserializationState = null,
 			int retried = 0,
 			int? seed = null)
 		{
@@ -80,7 +82,7 @@ public ElasticsearchResponse<T> DoRequest<T>(
 			if (queryString != null) path += queryString.ToQueryString();
 
 			var postData = PostData(data);
-			ElasticsearchResponse<T> response = null;
+			IElasticsearchResponse response = null;
 
 			int initialSeed; bool shouldPingHint;
 			var baseUri = this._connectionPool.GetNext(seed, out initialSeed, out shouldPingHint);
@@ -92,9 +94,13 @@ public ElasticsearchResponse<T> DoRequest<T>(
 					this._connection.Ping(CreateUriToPath(baseUri, ""));
 
 				var uri = CreateUriToPath(baseUri, path);
-				response = _doRequest<T>(method, uri, postData, deserializationState);
-				if (response != null && response.SuccessOrKnownError)
-					return response;
+				var streamResponse = _doRequest(method, uri, postData, null);
+				if (streamResponse != null && streamResponse.SuccessOrKnownError)
+				{
+					var typedResponse = this.StreamToTypedResponse<T>(streamResponse, deserializationState);
+					response = typedResponse;
+					return typedResponse;
+				}
 			}
 			catch (Exception e)
 			{
@@ -119,7 +125,7 @@ private ElasticsearchResponse<T> RetryRequest<T>(
 		{
 			var maxRetries = this.GetMaximumRetries();
 			var exceptionMessage = "Unable to perform request: '{0} {1}' on any of the nodes after retrying {2} times."
-				.F( method, path.IsNullOrEmpty() ? "/" : "", retried);
+				.F(method, path.IsNullOrEmpty() ? "/" : "", retried);
 			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);
 			if (this._configurationValues.SniffsOnConnectionFault && retried == 0)
 				this.Sniff();
@@ -131,22 +137,22 @@ private ElasticsearchResponse<T> RetryRequest<T>(
 			throw new MaxRetryException(exceptionMessage, e);
 		}
 
-		private ElasticsearchResponse<T> _doRequest<T>(string method, Uri uri, byte[] postData, object deserializationState)
+		private ElasticsearchResponse<Stream> _doRequest(string method, Uri uri, byte[] postData, IConnectionConfigurationOverrides requestSpecificConfig)
 		{
 			switch (method.ToLowerInvariant())
 			{
 				case "post":
-					return this._connection.PostSync<T>(uri, postData, deserializationState);
+					return this._connection.PostSync(uri, postData, requestSpecificConfig);
 				case "put":
-					return this._connection.PutSync<T>(uri, postData, deserializationState);
+					return this._connection.PutSync(uri, postData, requestSpecificConfig);
 				case "delete":
 					return postData == null || postData.Length == 0
-						? this._connection.DeleteSync<T>(uri, deserializationState)
-						: this._connection.DeleteSync<T>(uri, postData, deserializationState);
+						? this._connection.DeleteSync(uri, requestSpecificConfig)
+						: this._connection.DeleteSync(uri, postData, requestSpecificConfig);
 				case "head":
-					return this._connection.HeadSync<T>(uri, deserializationState);
+					return this._connection.HeadSync(uri, requestSpecificConfig);
 				case "get":
-					return this._connection.GetSync<T>(uri, deserializationState);
+					return this._connection.GetSync(uri, requestSpecificConfig);
 			}
 			throw new Exception("Unknown HTTP method " + method);
 		}
@@ -161,7 +167,7 @@ public Task<ElasticsearchResponse<T>> DoRequestAsync<T>(
 			int? seed = null)
 		{
 			SniffIfInformationIsTooOld(retried);
-			
+
 			if (queryString != null) path += queryString.ToQueryString();
 
 			var postData = PostData(data);
@@ -179,17 +185,18 @@ public Task<ElasticsearchResponse<T>> DoRequestAsync<T>(
 				}
 			}
 			var uri = CreateUriToPath(baseUri, path);
-			return _doRequestAsync<T>(method, uri, postData, deserializationState).ContinueWith(t=>
+			
+			return _doRequestAsync(method, uri, postData, null).ContinueWith(t =>
 			{
 				if (t.IsCanceled)
 					return null;
 				if (t.IsFaulted)
 					return this.RetryRequestAsync<T>(method, path, data, deserializationState, retried, baseUri, initialSeed, t.Exception);
 				if (t.Result.SuccessOrKnownError)
-					return t;
+					return this.StreamToTypedResponseAsync<T>(t.Result, deserializationState);
 				return this.RetryRequestAsync<T>(method, path, data, deserializationState, retried, baseUri, initialSeed, null);
-					
-			}).Unwrap<ElasticsearchResponse<T>>();
+
+			}).Unwrap();
 		}
 		private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(
 			string method, string path, object data, object deserializationState, int retried, Uri baseUri,
@@ -197,7 +204,7 @@ private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(
 		{
 			var maxRetries = this.GetMaximumRetries();
 			var exceptionMessage = "Unable to perform request: '{0} {1}' on any of the nodes after retrying {2} times."
-				.F( method, path, retried);
+				.F(method, path, retried);
 			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);
 			if (this._configurationValues.SniffsOnConnectionFault && retried == 0)
 				this.Sniff();
@@ -207,26 +214,27 @@ private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(
 			}
 			throw new MaxRetryException(exceptionMessage, e);
 		}
-		private Task<ElasticsearchResponse<T>> _doRequestAsync<T>(string method, Uri uri, byte[] postData, object deserializationState)
+
+		private Task<ElasticsearchResponse<Stream>> _doRequestAsync(string method, Uri uri, byte[] postData, IConnectionConfigurationOverrides requestSpecificConfig)
 		{
 			switch (method.ToLowerInvariant())
 			{
 				case "post":
-					return this._connection.Post<T>(uri, postData, deserializationState);
+					return this._connection.Post(uri, postData, requestSpecificConfig);
 				case "put":
-					return this._connection.Put<T>(uri, postData, deserializationState);
+					return this._connection.Put(uri, postData, requestSpecificConfig);
 				case "delete":
 					return postData == null || postData.Length == 0
-						? this._connection.Delete<T>(uri, deserializationState)
-						: this._connection.Delete<T>(uri, postData, deserializationState);
+						? this._connection.Delete(uri, requestSpecificConfig)
+						: this._connection.Delete(uri, postData, requestSpecificConfig);
 				case "head":
-					return this._connection.Head<T>(uri, deserializationState);
+					return this._connection.Head(uri, requestSpecificConfig);
 				case "get":
-					return this._connection.Get<T>(uri, deserializationState);
+					return this._connection.Get(uri, requestSpecificConfig);
 			}
 			throw new Exception("Unknown HTTP method " + method);
 		}
-		
+
 		private Uri CreateUriToPath(Uri baseUri, string path)
 		{
 			var s = this.Settings;
@@ -239,7 +247,7 @@ private Uri CreateUriToPath(Uri baseUri, string path)
 			var uri = path.IsNullOrEmpty() ? baseUri : new Uri(baseUri, path);
 			return uri.Purify();
 		}
-		
+
 		private byte[] PostData(object data)
 		{
 			var bytes = data as byte[];
@@ -253,7 +261,7 @@ private byte[] PostData(object data)
 			var ss = data as IEnumerable<string>;
 			if (ss != null)
 				return (string.Join("\n", ss) + "\n").Utf8Bytes();
-			
+
 			var so = data as IEnumerable<object>;
 			if (so == null)
 				return this._serializer.Serialize(data);
@@ -261,5 +269,205 @@ private byte[] PostData(object data)
 				.Select(soo => this._serializer.Serialize(soo, SerializationFormatting.None).Utf8String())) + "\n";
 			return joined.Utf8Bytes();
 		}
+
+		public void SetStringResult(ElasticsearchResponse<string> response, byte[] rawResponse)
+		{
+			response.Response = rawResponse.Utf8String();
+		}
+
+		public void SetByteResult(ElasticsearchResponse<byte[]> response, byte[] rawResponse)
+		{
+			response.Response = rawResponse;
+		}
+
+		private ElasticsearchResponse<T> StreamToTypedResponse<T>(ElasticsearchResponse<Stream> streamResponse, object deserializationState)
+		{
+			//if the user explicitly wants a stream returned the undisposed stream
+			if (typeof(Stream).IsAssignableFrom(typeof(T)))
+				return streamResponse as ElasticsearchResponse<T>;
+
+			ElasticsearchResponse<T> cs = ElasticsearchResponse.CloneFrom<T>(streamResponse, default(T));
+			using (streamResponse.Response)
+			using (var memoryStream = new MemoryStream())
+			{
+				if (typeof(T) == typeof(VoidResponse))
+					return cs;
+
+				var type = typeof(T);
+				if (!(this.Settings.KeepRawResponse || type == typeof(string) || type == typeof(byte[])))
+					return this._deserializeToResponse(streamResponse.Response, deserializationState, cs);
+
+				if (streamResponse.Response != null)
+					streamResponse.Response.CopyTo(memoryStream);
+				memoryStream.Position = 0;
+				var bytes = memoryStream.ToArray();
+				cs.ResponseRaw = this.Settings.KeepRawResponse ? bytes : null;
+				if (type == typeof(string))
+				{
+					this.SetStringResult(cs as ElasticsearchResponse<string>, bytes);
+					return cs;
+				}
+				if (type == typeof(byte[]))
+				{
+					this.SetByteResult(cs as ElasticsearchResponse<byte[]>, bytes);
+					return cs;
+				}
+				return this._deserializeToResponse(memoryStream, deserializationState, cs);
+			}
+		}
+
+		private Task<ElasticsearchResponse<T>> StreamToTypedResponseAsync<T>(ElasticsearchResponse<Stream> streamResponse, object deserializationState)
+		{
+			var tcs = new TaskCompletionSource<ElasticsearchResponse<T>>();
+
+			//if the user explicitly wants a stream return the undisposed stream
+			if (typeof(Stream).IsAssignableFrom(typeof(T)))
+			{
+				tcs.SetResult(streamResponse as ElasticsearchResponse<T>);
+				return tcs.Task;
+			}
+
+			var cs = ElasticsearchResponse.CloneFrom<T>(streamResponse, default(T));
+
+			var memoryStream = new MemoryStream();
+			if (typeof(T) == typeof(VoidResponse))
+			{
+				tcs.SetResult(cs);
+				if (streamResponse.Response != null)
+					streamResponse.Response.Dispose();
+				return tcs.Task;
+			}
+
+			var type = typeof(T);
+			if (!(this.Settings.KeepRawResponse || type == typeof(string) || type == typeof(byte[])))
+				return _deserializeAsyncToResponse(streamResponse.Response, deserializationState, cs);
+
+			return this.Iterate(this.ReadStreamAsync(streamResponse.Response, memoryStream), memoryStream)
+				.ContinueWith(t =>
+				{
+					var readStream = t.Result;
+					readStream.Position = 0;
+					var bytes = readStream.ToArray();
+					cs.ResponseRaw = this.Settings.KeepRawResponse ? bytes : null;
+					if (type == typeof(string))
+					{
+						this.SetStringResult(cs as ElasticsearchResponse<string>, bytes);
+						tcs.SetResult(cs);
+						return tcs.Task;
+					}
+					if (type == typeof(byte[]))
+					{
+						this.SetByteResult(cs as ElasticsearchResponse<byte[]>, bytes);
+						tcs.SetResult(cs);
+						return tcs.Task;
+					}
+
+					return _deserializeAsyncToResponse(readStream, deserializationState, cs);
+				})
+				.Unwrap();
+
+		}
+		
+		private ElasticsearchResponse<T> _deserializeToResponse<T>(Stream response, object deserializationState, ElasticsearchResponse<T> cs)
+		{
+			if (response == null
+				|| (!cs.HttpStatusCode.HasValue)
+				|| ((cs.HttpStatusCode.Value < 200 || cs.HttpStatusCode >= 300) && cs.HttpStatusCode != 404)
+				)
+				return cs;
+
+			var customConverter = deserializationState as Func<IElasticsearchResponse, Stream, T>;
+			if (customConverter != null)
+			{
+				using (response)
+				{
+					var t = customConverter(cs, response);
+					cs.Response = t;
+					return cs;
+				}
+			}
+			var deserialized = this.Serializer.Deserialize<T>(cs, response, deserializationState);
+			cs.Response = deserialized;
+			return cs;
+		}
+
+		private Task<ElasticsearchResponse<T>> _deserializeAsyncToResponse<T>(Stream response, object deserializationState, ElasticsearchResponse<T> cs)
+		{
+			var tcs = new TaskCompletionSource<ElasticsearchResponse<T>>();
+			if (response == null
+				|| (!cs.HttpStatusCode.HasValue)
+				|| ((cs.HttpStatusCode.Value < 200 || cs.HttpStatusCode >= 300) && cs.HttpStatusCode != 404)
+				)
+			{
+				tcs.SetResult(cs);
+				return null;
+			}
+			var customConverter = deserializationState as Func<IElasticsearchResponse, Stream, T>;
+			if (customConverter != null)
+			{
+				using (response)
+				{
+					var t = customConverter(cs, response);
+					cs.Response = t;
+					tcs.SetResult(cs);
+					return tcs.Task;
+				}
+			}
+			return this.Serializer.DeserializeAsync<T>(cs, response, deserializationState)
+				.ContinueWith(t =>
+				{
+					cs.Response = t.Result;
+					return cs;
+				});
+		}
+
+		const int BUFFER_SIZE = 4096;
+		public IEnumerable<Task<MemoryStream>> ReadStreamAsync(Stream responseStream, MemoryStream memoryStream)
+		{
+			var buffer = new byte[BUFFER_SIZE];
+			try
+			{
+				while (responseStream != null)
+				{
+					var read = Task<int>.Factory.FromAsync(responseStream.BeginRead, responseStream.EndRead, buffer, 0, BUFFER_SIZE, null);
+					yield return read.ContinueWith(t => memoryStream);
+					if (read.Result == 0) break;
+					memoryStream.Write(buffer, 0, read.Result);
+				}
+			}
+			finally
+			{
+				if (responseStream != null)
+					responseStream.Dispose();
+			}
+		}
+
+		public Task<MemoryStream> Iterate(IEnumerable<Task> asyncIterator, MemoryStream memoryStream)
+		{
+			var tcs = new TaskCompletionSource<MemoryStream>();
+			var enumerator = asyncIterator.GetEnumerator();
+			Action<Task> recursiveBody = null;
+			recursiveBody = completedTask =>
+			{
+				if (completedTask != null && completedTask.IsFaulted)
+				{
+					var exception = completedTask.Exception.InnerException;
+					tcs.TrySetException(exception);
+					enumerator.Dispose();
+				}
+				else if (enumerator.MoveNext())
+				{
+					enumerator.Current.ContinueWith(recursiveBody);
+				}
+				else
+				{
+					tcs.SetResult(memoryStream);
+					enumerator.Dispose();
+				}
+			};
+			recursiveBody(null);
+			return tcs.Task;
+		}
+
 	}
 }
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs b/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
index 9814b1268bf..1ce7bd408e2 100644
--- a/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
+++ b/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
@@ -18,21 +18,24 @@
 
 namespace Elasticsearch.Net
 {
+	//TODO document and possibly rename some of the properties
+
 	public interface IElasticsearchResponse
 	{
 		bool Success { get; }
+		bool SuccessOrKnownError { get; }
 		IConnectionConfigurationValues Settings { get; }
-		ConnectionError Error { get; }
+		Exception OriginalException { get; }
 		string RequestMethod { get; }
 		string RequestUrl { get; }
-        [DebuggerDisplay("{Request != null ? System.Text.Encoding.UTF8.GetString(Request) : null,nq}")]
+		[DebuggerDisplay("{Request != null ? System.Text.Encoding.UTF8.GetString(Request) : null,nq}")]
 		byte[] Request { get; }
 		int? HttpStatusCode { get; }
-		
+
 		/// <summary>
 		/// The raw byte response, only set when IncludeRawResponse() is set on Connection configuration
 		/// </summary>
-        [DebuggerDisplay("{ResponseRaw != null ? System.Text.Encoding.UTF8.GetString(ResponseRaw) : null,nq}")]
+		[DebuggerDisplay("{ResponseRaw != null ? System.Text.Encoding.UTF8.GetString(ResponseRaw) : null,nq}")]
 		byte[] ResponseRaw { get; }
 	}
 
@@ -42,7 +45,7 @@ internal static class ElasticsearchResponse
 		public static Task<ElasticsearchResponse<DynamicDictionary>> WrapAsync(Task<ElasticsearchResponse<Dictionary<string, object>>> responseTask)
 		{
 			return responseTask
-				.ContinueWith(t=>ToDynamicResponse(t.Result));
+				.ContinueWith(t => ToDynamicResponse(t.Result));
 		}
 
 		public static ElasticsearchResponse<DynamicDictionary> Wrap(ElasticsearchResponse<Dictionary<string, object>> response)
@@ -50,22 +53,27 @@ public static ElasticsearchResponse<DynamicDictionary> Wrap(ElasticsearchRespons
 			return ToDynamicResponse(response);
 		}
 
-		private static ElasticsearchResponse<DynamicDictionary> ToDynamicResponse(ElasticsearchResponse<Dictionary<string, object>> response)
+		public static ElasticsearchResponse<TTo> CloneFrom<TTo>(IElasticsearchResponse from, TTo to)
 		{
-			return new ElasticsearchResponse<DynamicDictionary>(response.Settings)
+			return new ElasticsearchResponse<TTo>(from.Settings)
 			{
-				Error = response.Error,
-				HttpStatusCode = response.HttpStatusCode,
-				Request = response.Request,
-				RequestMethod = response.RequestMethod,
-				RequestUrl = response.RequestUrl,
-				Response = response.Response != null ? DynamicDictionary.Create(response.Response) : null,
-				ResponseRaw = response.ResponseRaw,
-				Serializer = response.Serializer,
-				Settings = response.Settings,
-				Success = response.Success
+				OriginalException = from.OriginalException,
+				HttpStatusCode = from.HttpStatusCode,
+				Request = from.Request,
+				RequestMethod = from.RequestMethod,
+				RequestUrl = from.RequestUrl,
+				Response = to,
+				ResponseRaw = from.ResponseRaw,
+				Serializer = from.Settings.Serializer,
+				Settings = from.Settings,
+				Success = from.Success
 			};
 		}
+
+		private static ElasticsearchResponse<DynamicDictionary> ToDynamicResponse(ElasticsearchResponse<Dictionary<string, object>> response)
+		{
+			return CloneFrom(response, response.Response != null ? DynamicDictionary.Create(response.Response) : null);
+		}
 	}
 
 
@@ -73,18 +81,21 @@ public class ElasticsearchResponse<T> : IElasticsearchResponse
 	{
 		protected static readonly string _printFormat;
 		protected static readonly string _errorFormat;
-		
+
 		public bool Success { get; protected internal set; }
-		public ConnectionError Error { get; protected internal set; }
+
+		public Exception OriginalException { get; protected internal set; }
 
 		public string RequestMethod { get; protected internal set; }
+
 		public string RequestUrl { get; protected internal set; }
+
 		public IConnectionConfigurationValues Settings { get; protected internal set; }
 
 		public T Response { get; protected internal set; }
-		
+
 		public byte[] Request { get; protected internal set; }
-		
+
 		/// <summary>
 		/// The raw byte response, only set when IncludeRawResponse() is set on Connection configuration
 		/// </summary>
@@ -98,42 +109,38 @@ public class ElasticsearchResponse<T> : IElasticsearchResponse
 		/// If the response is succesful or has a known error (400-500 range)
 		/// The client should not retry this call
 		/// </summary>
-		internal bool SuccessOrKnownError
+		public bool SuccessOrKnownError
 		{
 			get
 			{
 				return this.Success ||
-					(this.HttpStatusCode.HasValue 
+					(this.HttpStatusCode.HasValue
 					&& this.HttpStatusCode.Value != 503 //service unavailable needs to be retried
 					&& this.HttpStatusCode.Value != 502 //bad gateway needs to be retried 
 					&& ((this.HttpStatusCode.Value >= 400 && this.HttpStatusCode.Value < 599)));
 			}
 		}
 
-
 		protected internal ElasticsearchResponse(IConnectionConfigurationValues settings)
 		{
 			this.Settings = settings;
-			this.Serializer = settings.Serializer; 
+			this.Serializer = settings.Serializer;
 		}
-		private ElasticsearchResponse(IConnectionConfigurationValues settings, Exception e) : this(settings)
+
+		private ElasticsearchResponse(IConnectionConfigurationValues settings, Exception e)
+			: this(settings)
 		{
 			this.Success = false;
-			this.Error = new ConnectionError(e);
-			if (this.Error.HttpStatusCode != null)
-				this.HttpStatusCode = (int) this.Error.HttpStatusCode;
-			this.ResponseRaw = this.Error.ResponseReadFromWebException;
+			this.OriginalException = e;
 		}
-		private ElasticsearchResponse(IConnectionConfigurationValues settings, int statusCode) : this(settings)
+
+		private ElasticsearchResponse(IConnectionConfigurationValues settings, int statusCode)
+			: this(settings)
 		{
 			this.Success = statusCode >= 200 && statusCode < 300;
-			if (!this.Success)
-			{
-				var exception = new ConnectionException(statusCode);
-				this.Error = new ConnectionError(exception);
-			}
 			this.HttpStatusCode = statusCode;
 		}
+
 		public static ElasticsearchResponse<T> CreateError(IConnectionConfigurationValues settings, Exception e, string method, string path, byte[] request)
 		{
 			var cs = new ElasticsearchResponse<T>(settings, e);
@@ -142,6 +149,7 @@ public static ElasticsearchResponse<T> CreateError(IConnectionConfigurationValue
 			cs.RequestMethod = method;
 			return cs;
 		}
+
 		public static ElasticsearchResponse<T> Create(IConnectionConfigurationValues settings, int statusCode, string method, string path, byte[] request)
 		{
 			var cs = new ElasticsearchResponse<T>(settings, statusCode);
@@ -151,33 +159,14 @@ public static ElasticsearchResponse<T> Create(IConnectionConfigurationValues set
 			return cs;
 		}
 
-		public static ElasticsearchResponse<T> Create(
-			IConnectionConfigurationValues settings, int statusCode, string method, string path, byte[] request, Stream stream, object deserializeState = null)
+		public static ElasticsearchResponse<T> Create(IConnectionConfigurationValues settings, int statusCode, string method, string path, byte[] request, T response)
 		{
 			var cs = new ElasticsearchResponse<T>(settings, statusCode);
 			cs.Request = request;
 			cs.RequestUrl = path;
 			cs.RequestMethod = method;
-			var s = stream;
-			using (var ms = new MemoryStream())
-			{
-				if (settings.KeepRawResponse)
-				{
-					stream.CopyTo(ms);
-					cs.ResponseRaw = ms.ToArray();
-					ms.Position = 0;
-					s = ms;
-				}
-				var customConverter = deserializeState as Func<IElasticsearchResponse, Stream, T>;
-				if (customConverter != null)
-				{
-					var t = customConverter(cs, s);
-					cs.Response = t;
-				}
-				else cs.Response = settings.Serializer.Deserialize<T>(cs, s, deserializeState);
-
-				return cs;
-			}
+			cs.Response = response;
+			return cs;
 		}
 
 		static ElasticsearchResponse()
@@ -189,7 +178,7 @@ static ElasticsearchResponse()
 		public override string ToString()
 		{
 			var r = this;
-			var e = r.Error;
+			var e = r.OriginalException;
 			string response = "<Response stream not captured or already read to completion by serializer>";
 			if (typeof(T) == typeof(string))
 				response = this.Response as string;
@@ -206,9 +195,9 @@ public override string ToString()
 			  r.Request,
 			  response
 			);
-			if (!this.Success)
+			if (!this.Success && e != null)
 			{
-				print += _errorFormat.F(Environment.NewLine, e.ExceptionMessage, e.OriginalException.StackTrace);
+				print += _errorFormat.F(Environment.NewLine, e.Message, e.StackTrace);
 			}
 			return print;
 		}
diff --git a/src/Elasticsearch.sln b/src/Elasticsearch.sln
index e704682f680..e2726eddda8 100644
--- a/src/Elasticsearch.sln
+++ b/src/Elasticsearch.sln
@@ -260,6 +260,7 @@ Global
 		{E97CCF40-0BA6-43FE-9F2D-58D454134088}.CodeGeneration|Any CPU.ActiveCfg = Release|Any CPU
 		{E97CCF40-0BA6-43FE-9F2D-58D454134088}.CodeGeneration|Any CPU.Build.0 = Release|Any CPU
 		{E97CCF40-0BA6-43FE-9F2D-58D454134088}.CodeGeneration|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{E97CCF40-0BA6-43FE-9F2D-58D454134088}.CodeGeneration|Mixed Platforms.Build.0 = Release|Any CPU
 		{E97CCF40-0BA6-43FE-9F2D-58D454134088}.CodeGeneration|x86.ActiveCfg = Release|Any CPU
 		{E97CCF40-0BA6-43FE-9F2D-58D454134088}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{E97CCF40-0BA6-43FE-9F2D-58D454134088}.Debug|Any CPU.Build.0 = Debug|Any CPU
diff --git a/src/Nest/Domain/Responses/IndexExistsResponse.cs b/src/Nest/Domain/Responses/IndexExistsResponse.cs
index ed58811cb82..3197baabf75 100644
--- a/src/Nest/Domain/Responses/IndexExistsResponse.cs
+++ b/src/Nest/Domain/Responses/IndexExistsResponse.cs
@@ -15,8 +15,8 @@ public class IndexExistsResponse : BaseResponse, IIndexExistsResponse
 		internal IndexExistsResponse(IElasticsearchResponse connectionStatus)
 		{
 			this.ConnectionStatus = connectionStatus;
-			this.IsValid = connectionStatus.Error == null || connectionStatus.Error.HttpStatusCode == HttpStatusCode.NotFound;
-			this.Exists = connectionStatus.Error == null && connectionStatus.Success;
+			this.IsValid =connectionStatus.Success || connectionStatus.HttpStatusCode == 404;
+			this.Exists = connectionStatus.Success & connectionStatus.HttpStatusCode == 200;
 		}
 
 		public bool Exists { get; internal set; }
diff --git a/src/Profiling/Profiling.Indexing/Tester.cs b/src/Profiling/Profiling.Indexing/Tester.cs
index 59e07eddc31..32167debf25 100644
--- a/src/Profiling/Profiling.Indexing/Tester.cs
+++ b/src/Profiling/Profiling.Indexing/Tester.cs
@@ -28,7 +28,7 @@ protected void Connect(ElasticClient client, ConnectionSettings settings)
 			if (!result.IsValid)
 			{
 				Console.Error.WriteLine("Could not connect to {0}:\r\n{1}",
-					result.ConnectionStatus.RequestUrl, result.ConnectionStatus.Error.OriginalException.Message);
+					result.ConnectionStatus.RequestUrl, result.ConnectionStatus);
 				Console.Read();
 			}
 		}
diff --git a/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs b/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
index e4a99daca5f..6208e65f602 100644
--- a/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
+++ b/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
@@ -62,19 +62,16 @@ protected void Do(Func<ElasticsearchResponse<DynamicDictionary>> action, string
 			}
 			if (shouldCatch == "missing")
 			{
-				Assert.NotNull(this._status.Error, "call specified missing is expected");
-				Assert.AreEqual(this._status.Error.HttpStatusCode,HttpStatusCode.NotFound, "call specified missing (404) is expected");
+				Assert.AreEqual(this._status.HttpStatusCode, 404, "call specified missing (404) is expected");
 			}
 			else if (shouldCatch == "conflict")
 			{
-				Assert.NotNull(this._status.Error, "call specified conflict is expected");
-				Assert.AreEqual(this._status.Error.HttpStatusCode,HttpStatusCode.Conflict, "call specified conflict (409) is expected");
+				Assert.AreEqual(this._status.HttpStatusCode, 409, "call specified conflict (409) is expected");
 				
 			}
 			else if (shouldCatch == "forbidden")
 			{
-				Assert.NotNull(this._status.Error, "call specified forbidden is expected");
-				Assert.AreEqual(this._status.Error.HttpStatusCode,HttpStatusCode.Forbidden, "call specified conflict (403) is expected");
+				Assert.AreEqual(this._status.HttpStatusCode, 403, "call specified conflict (403) is expected");
 				
 			}
 			else if (shouldCatch != null && shouldCatch.StartsWith("/"))
@@ -108,9 +105,9 @@ protected void IsTrue(object o)
 			if (o is IElasticsearchResponse)
 			{
 				var c = o as IElasticsearchResponse;
-				if (c.RequestMethod == "HEAD" && c.Error != null)
+				if (c.RequestMethod == "HEAD" && !c.Success)
 				{
-					Assert.Fail("HEAD request returned status:" + c.Error.HttpStatusCode);
+					Assert.Fail("HEAD request returned status:" + c.HttpStatusCode);
 				}
 				else if (c.RequestMethod == "HEAD") return;
 			}
@@ -160,10 +157,10 @@ protected void IsFalse(object o)
 			if (o is IElasticsearchResponse)
 			{
 				var c = o as IElasticsearchResponse;
-				if (c.RequestMethod == "HEAD" && c.Error == null)
+				if (c.RequestMethod == "HEAD" && c.Success)
 				{
 					Assert.Fail("HEAD request did not return error status but:" 
-						+ c.Error.HttpStatusCode);
+						+ c.HttpStatusCode);
 				}
 				else if (c.RequestMethod == "HEAD") return;
 			}
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs
index 0c4d1d31331..93cb262cf96 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Net;
 using System.Runtime.InteropServices;
@@ -139,13 +140,13 @@ public override IList<Uri> Sniff(Uri uri)
 				return  _rnd.Next(1, 11) % 3 == 0 ? _uris : _uris2;
 			}
 
-			public override ElasticsearchResponse<T> GetSync<T>(Uri uri, object deserializationState = null)
+			public override ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestConfigurationOverrides = null)
 			{
 				var statusCode = _rnd.Next(1, 9) % 3 == 0 ? 503 : 200;
 				if (uri.Port == 9202)
 					statusCode = 200;
 
-				return ElasticsearchResponse<T>.Create(this._ConnectionSettings, statusCode, "GET", "/", null);
+				return ElasticsearchResponse<Stream>.Create(this._ConnectionSettings, statusCode, "GET", "/", null);
 			
 			}
 		}
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs
index edd02abb503..9c2d5df2218 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -56,8 +57,8 @@ public async void ThrowsOutOfNodesException_AndRetriesTheSpecifiedTimes_Async()
 				var getCall = FakeCalls.GetCall(fake); 
 
 				//return a started task that throws
-				Func<ElasticsearchResponse<Dictionary<string, object>>> badTask = () => { throw new Exception(); };
-				var t = new Task<ElasticsearchResponse<Dictionary<string, object>>>(badTask);
+				Func<ElasticsearchResponse<Stream>> badTask = () => { throw new Exception(); };
+				var t = new Task<ElasticsearchResponse<Stream>>(badTask);
 				t.Start();
 				getCall.Returns(t);
 				
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
index 6a17956f13a..554da31afbf 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
@@ -201,7 +201,7 @@ public void HostsReturnedBySniffAreVisited()
 
 				var seenNodes = new List<Uri>();
 				//var getCall =  FakeResponse.GetSyncCall(fake);
-				var getCall = A.CallTo(() => connection.GetSync<Dictionary<string, object>>(A<Uri>._, A<object>._));
+				var getCall = A.CallTo(() => connection.GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
 				getCall.ReturnsNextFromSequence(
 					FakeResponse.Ok(config), //info 1
 					FakeResponse.Bad(config), //info 2
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs
index e6a64e9bbb8..fd342a94ea1 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Net;
 using System.Runtime.InteropServices;
@@ -126,7 +127,7 @@ public void HardRetryLimitTakesPrecedenceOverNumberOfNodes()
 						.MaximumRetries(7)
 				);
 				var getCall = A.CallTo(() => 
-					fake.Resolve<IConnection>().GetSync<Dictionary<string, object>>(A<Uri>._, A<object>._));
+					fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
 				getCall.Throws<Exception>();
 				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
 				pingCall.Returns(true);
@@ -157,14 +158,13 @@ public void AConnectionMustBeMadeEvenIfAllNodesAreDead()
 						.MaximumRetries(4)
 				);
 				//set up our GET to / to return 4 503's followed by a 200
-				var getCall = A.CallTo(() => 
-					fake.Resolve<IConnection>().GetSync<Dictionary<string, object>>(A<Uri>._, A<object>._));
+				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
 				getCall.ReturnsNextFromSequence(
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 200, "GET", "/", null)
+					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
+					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
+					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
+					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
+					ElasticsearchResponse<Stream>.Create(_config, 200, "GET", "/", null)
 				);
 				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
 				pingCall.Returns(true);
@@ -215,10 +215,9 @@ public void AllNodesWillBeMarkedDead()
 					call.Returns(DateTime.UtcNow.AddSeconds(60));
 				
 				//When we do a GET on / we always recieve a 503
-				var getCall = A.CallTo(() => 
-					fake.Resolve<IConnection>().GetSync<Dictionary<string, object>>(A<Uri>._, A<object>._));
+				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
 				getCall.Returns(
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null)
+					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null)
 				);
 				
 				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
@@ -263,14 +262,13 @@ public void IfAConnectionComesBackToLifeOnItsOwnItShouldBeMarked()
 
 				//fake getsync handler that return a 503 4 times and then a 200
 				//this will cause all 4 nodes to be marked dead on the first client call
-				var getCall = A.CallTo(() => 
-					fake.Resolve<IConnection>().GetSync<Dictionary<string, object>>(A<Uri>._, A<object>._));
+				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
 				getCall.ReturnsNextFromSequence(
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Dictionary<string, object>>.Create(_config, 200, "GET", "/", null)
+					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
+					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
+					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
+					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
+					ElasticsearchResponse<Stream>.Create(_config, 200, "GET", "/", null)
 				);
 				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
 				pingCall.Returns(true);
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
index bc4485a2200..228eb1ee976 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.IO;
 using System.Threading.Tasks;
 using Autofac;
 using Autofac.Extras.FakeItEasy;
@@ -13,15 +14,13 @@ namespace Elasticsearch.Net.Tests.Unit.Stubs
 {
 	public static class FakeCalls 
 	{
-		public static IReturnValueConfiguration<ElasticsearchResponse<Dictionary<string, object>>> GetSyncCall(AutoFake fake)
+		public static IReturnValueConfiguration<ElasticsearchResponse<Stream>> GetSyncCall(AutoFake fake)
 		{
-			return A.CallTo(() =>
-				fake.Resolve<IConnection>().GetSync<Dictionary<string, object>>(A<Uri>._, null));
+			return A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, null));
 		}
-		public static IReturnValueArgumentValidationConfiguration<Task<ElasticsearchResponse<Dictionary<string, object>>>> GetCall(AutoFake fake)
+		public static IReturnValueArgumentValidationConfiguration<Task<ElasticsearchResponse<Stream>>> GetCall(AutoFake fake)
 		{
-			return A.CallTo(() => 
-				fake.Resolve<IConnection>().Get<Dictionary<string, object>>(A<Uri>._, A<object>._));
+			return A.CallTo(() => fake.Resolve<IConnection>().Get(A<Uri>._, A<IConnectionConfigurationOverrides>._));
 		}
 
 		public static IReturnValueArgumentValidationConfiguration<bool> Ping(AutoFake fake)
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeResponse.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeResponse.cs
index 843d01de08e..d62881aed74 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeResponse.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeResponse.cs
@@ -1,32 +1,33 @@
 using System.Collections.Generic;
+using System.IO;
 using Elasticsearch.Net.Connection;
 
 namespace Elasticsearch.Net.Tests.Unit.Stubs
 {
 	public static class FakeResponse
 	{
-		public static ElasticsearchResponse<Dictionary<string, object>> Ok(
+		public static ElasticsearchResponse<Stream> Ok(
 			IConnectionConfigurationValues config, 
 			string method = "GET",
 			string path = "/")
 		{
-			return ElasticsearchResponse<Dictionary<string, object>>.Create(config, 200, method, path, null);
+			return ElasticsearchResponse<Stream>.Create(config, 200, method, path, null);
 		}
 		
-		public static ElasticsearchResponse<Dictionary<string, object>> Bad(
+		public static ElasticsearchResponse<Stream> Bad(
 			IConnectionConfigurationValues config, 
 			string method = "GET",
 			string path = "/")
 		{
-			return ElasticsearchResponse<Dictionary<string, object>>.Create(config, 503, method, path, null);
+			return ElasticsearchResponse<Stream>.Create(config, 503, method, path, null);
 		}
-		public static ElasticsearchResponse<Dictionary<string, object>> Any(
+		public static ElasticsearchResponse<Stream> Any(
 			IConnectionConfigurationValues config, 
 			int statusCode,
 			string method = "GET",
 			string path = "/")
 		{
-			return ElasticsearchResponse<Dictionary<string, object>>.Create(config, statusCode, method, path, null);
+			return ElasticsearchResponse<Stream>.Create(config, statusCode, method, path, null);
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs
index 4d7b17e6321..e13a6596012 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
@@ -19,12 +20,12 @@ public virtual void Observe(Uri uri) { }
 
 	public interface IResponseGenerator
 	{
-		ElasticsearchResponse<T> Create<T>();
+		ElasticsearchResponse<Stream> Create();
 	}
 
 	public class ResponseGenerator : IResponseGenerator
 	{
-		public virtual ElasticsearchResponse<T> Create<T>()
+		public virtual ElasticsearchResponse<Stream> Create()
 		{
 			return null;
 		}
@@ -47,75 +48,75 @@ IConnectionConfigurationValues configValues
 		}
 
 
-		public virtual Task<ElasticsearchResponse<T>> Get<T>(Uri uri, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
-			return DoAsyncRequest<T>(uri);
+			return DoAsyncRequest(uri);
 		}
 
-		public virtual ElasticsearchResponse<T> GetSync<T>(Uri uri, object deserializationState = null) 
+		public virtual ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null) 
 		{
 			_uriObserver.Observe(uri);
-			return _responseGenerator.Create<T>();
+			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<T>> Head<T>(Uri uri, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return Task.FromResult(_responseGenerator.Create<T>());
+			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<T> HeadSync<T>(Uri uri, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return _responseGenerator.Create<T>();
+			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<T>> Post<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return Task.FromResult(_responseGenerator.Create<T>());
+			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<T> PostSync<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return _responseGenerator.Create<T>();
+			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<T>> Put<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return Task.FromResult(_responseGenerator.Create<T>());
+			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<T> PutSync<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return _responseGenerator.Create<T>();
+			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return Task.FromResult(_responseGenerator.Create<T>());
+			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<T> DeleteSync<T>(Uri uri, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return _responseGenerator.Create<T>();
+			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<T>> Delete<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return Task.FromResult(_responseGenerator.Create<T>());
+			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<T> DeleteSync<T>(Uri uri, byte[] data, object deserializationState = null)
+		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
-			return _responseGenerator.Create<T>();
+			return _responseGenerator.Create();
 		}
 
 		public bool Ping(Uri uri)
@@ -128,10 +129,10 @@ public IList<Uri> Sniff(Uri uri)
 			throw new NotImplementedException();
 		}
 
-		private Task<ElasticsearchResponse<T>> DoAsyncRequest<T>(Uri uri)
+		private Task<ElasticsearchResponse<Stream>> DoAsyncRequest(Uri uri)
 		{
 			_uriObserver.Observe(uri);
-			return Task.FromResult(_responseGenerator.Create<T>());
+			return Task.FromResult(_responseGenerator.Create());
 		}
 	}
 }
diff --git a/src/Tests/Nest.Tests.Integration/Connection/Thrift/ThiftBugReportTests.cs b/src/Tests/Nest.Tests.Integration/Connection/Thrift/ThiftBugReportTests.cs
index 1c522188f02..bfe544d9240 100644
--- a/src/Tests/Nest.Tests.Integration/Connection/Thrift/ThiftBugReportTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Connection/Thrift/ThiftBugReportTests.cs
@@ -23,8 +23,7 @@ public void IndexExistShouldNotThrowOn404()
 
 			unknownIndexResult.Exists.Should().BeFalse();
 
-			unknownIndexResult.ConnectionStatus.Error.Should().NotBeNull();
-			unknownIndexResult.ConnectionStatus.Error.HttpStatusCode.Should().Be(HttpStatusCode.NotFound);
+			unknownIndexResult.ConnectionStatus.HttpStatusCode.Should().Be(404);
 
 		}
 	}
diff --git a/src/Tests/Nest.Tests.Integration/ConnectionTests.cs b/src/Tests/Nest.Tests.Integration/ConnectionTests.cs
index 83e8d3df81f..6b73fc042d6 100644
--- a/src/Tests/Nest.Tests.Integration/ConnectionTests.cs
+++ b/src/Tests/Nest.Tests.Integration/ConnectionTests.cs
@@ -24,7 +24,7 @@ public void TestConnectSuccess()
 		{
 			var rootNodeInfo = _client.RootNodeInfo();
 			Assert.True(rootNodeInfo.IsValid);
-			Assert.Null(rootNodeInfo.ConnectionStatus.Error);
+			Assert.True(rootNodeInfo.ConnectionStatus.Success);
 		}
 		[Test]
 		public void construct_client_with_null()
@@ -81,7 +81,7 @@ public void TestConnectSuccessWithUri()
 			var result = client.RootNodeInfo();
 
 			Assert.True(result.IsValid);
-			Assert.Null(result.ConnectionStatus.Error);
+			Assert.NotNull(result.ConnectionStatus.HttpStatusCode);
 		}
 		[Test]
 		public void construct_client_with_null_uri()
diff --git a/src/Tests/Nest.Tests.Integration/Core/Get/GetFullTests.cs b/src/Tests/Nest.Tests.Integration/Core/Get/GetFullTests.cs
index 42e8ad2c00d..03f7553bee8 100644
--- a/src/Tests/Nest.Tests.Integration/Core/Get/GetFullTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Core/Get/GetFullTests.cs
@@ -56,7 +56,7 @@ public void GetUsingDescriptorWithTypeAndFields()
 			result.Fields.Should().NotBeNull();
 			result.Fields.FieldValues.Should().NotBeNull().And.HaveCount(4);
 			result.Fields.FieldValue<ElasticsearchProject, string>(p => p.Name).Should().BeEquivalentTo(new [] {"pyelasticsearch"});
-			result.Fields.FieldValue<ElasticsearchProject, string>(p => p.Id).Should().BeEquivalentTo( new []{1});
+			result.Fields.FieldValue<ElasticsearchProject, int>(p => p.Id).Should().BeEquivalentTo( new []{1});
 			result.Fields.FieldValue<ElasticsearchProject, string>(p => p.DoubleValue).Should().NotBeEquivalentTo(new [] {default(double) });
 
 		}
diff --git a/src/Tests/Nest.Tests.Integration/Core/Get/GetMultiTests.cs b/src/Tests/Nest.Tests.Integration/Core/Get/GetMultiTests.cs
index 1d0fe823109..4988ab66512 100644
--- a/src/Tests/Nest.Tests.Integration/Core/Get/GetMultiTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Core/Get/GetMultiTests.cs
@@ -92,7 +92,7 @@ public void GetMultiWithMetaData()
 
 			var fieldSelection = personHit.FieldSelection;
 			fieldSelection.Should().NotBeNull();
-			fieldSelection.FieldValue<Person, string>(p=>p.Id).Should().BeEquivalentTo(new []{authorId});
+			fieldSelection.FieldValue<Person, int>(p=>p.Id).Should().BeEquivalentTo(new []{authorId});
 			fieldSelection.FieldValue<Person, string>(p => p.FirstName)
 				.Should().NotBeEmpty();
 
diff --git a/src/Tests/Nest.Tests.Integration/Core/IndexTests.cs b/src/Tests/Nest.Tests.Integration/Core/IndexTests.cs
index 4c4d4206f4f..bfe70b7baf4 100644
--- a/src/Tests/Nest.Tests.Integration/Core/IndexTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Core/IndexTests.cs
@@ -45,7 +45,41 @@ public void IndexUsingCreateFlag()
 
 			// Make sure the index request failed with HTTP status 409 since document with same id already exists.
 			Assert.False(response.OK);
-			Assert.AreEqual(System.Net.HttpStatusCode.Conflict, response.ConnectionStatus.Error.HttpStatusCode);
+			Assert.AreEqual(409, response.ConnectionStatus.HttpStatusCode);
+		}
+		
+		[Test]
+		public void IndexUsingCreateFlagOnNoRawResponseClient()
+		{
+			// Document to be indexed.
+			var doc = new ElasticsearchProject
+			{
+				Country = "Mozambique",
+				Followers = new List<Person>(),
+				Id = idGen.Next(),
+				Name = "Test Document for 'IndexDocument' Create Flag"
+			};
+
+			// Index the document
+			var indexResult = this._clientNoRawResponse.Index<ElasticsearchProject>(doc, i => i.OpType(OpTypeOptions.Create));
+			indexResult.IsValid.Should().BeTrue();
+
+			// Grab the indexed document.
+			var foundDoc = this._clientNoRawResponse.Source<ElasticsearchProject>(doc.Id);
+
+			// Check that the document was successfully indexed.
+			Assert.NotNull(foundDoc);
+			Assert.AreEqual(doc.Country, foundDoc.Country);
+			Assert.AreEqual(doc.Followers.Count, foundDoc.Followers.Count);
+			Assert.AreEqual(doc.Id, foundDoc.Id);
+			Assert.AreEqual(doc.Name, foundDoc.Name);
+
+			// Now try to index the document again while using the Create Flag
+			var response = this._clientNoRawResponse.Index<ElasticsearchProject>(doc, i => i.OpType(OpTypeOptions.Create));
+
+			// Make sure the index request failed with HTTP status 409 since document with same id already exists.
+			Assert.False(response.OK);
+			Assert.AreEqual(409, response.ConnectionStatus.HttpStatusCode);
 		}
 	}
 }
diff --git a/src/Tests/Nest.Tests.Integration/ElasticsearchConfiguration.cs b/src/Tests/Nest.Tests.Integration/ElasticsearchConfiguration.cs
index 55915a57888..6d86c5367d4 100644
--- a/src/Tests/Nest.Tests.Integration/ElasticsearchConfiguration.cs
+++ b/src/Tests/Nest.Tests.Integration/ElasticsearchConfiguration.cs
@@ -28,6 +28,7 @@ public static ConnectionSettings Settings(int? port = null)
 		}
 
 		public static readonly ElasticClient Client = new ElasticClient(Settings());
+		public static readonly ElasticClient ClientNoRawResponse = new ElasticClient(Settings().ExposeRawResponse(false));
 		public static readonly ElasticClient ThriftClient = new ElasticClient(Settings(9500), new ThriftConnection(Settings(9500)));
 
 		public static string NewUniqueIndexName()
diff --git a/src/Tests/Nest.Tests.Integration/Facet/BaseFacetTestFixture.cs b/src/Tests/Nest.Tests.Integration/Facet/BaseFacetTestFixture.cs
index 8de6b2ba6ed..a3260396cec 100644
--- a/src/Tests/Nest.Tests.Integration/Facet/BaseFacetTestFixture.cs
+++ b/src/Tests/Nest.Tests.Integration/Facet/BaseFacetTestFixture.cs
@@ -13,7 +13,7 @@ protected void TestDefaultAssertions(IQueryResponse<ElasticsearchProject> queryR
         {
             Assert.True(queryResponse.IsValid, "response is not valid");
             Assert.NotNull(queryResponse.ConnectionStatus, "connection status is null");
-            Assert.Null(queryResponse.ConnectionStatus.Error, "connection status error is null");
+            Assert.Null(queryResponse.ConnectionStatus.OriginalException, "exception should not be set");
             Assert.True(queryResponse.Total > 0, "Query yielded no results as indicated by total returned from ES");
             Assert.True(queryResponse.Documents.Any(), "documents.any() is false");
             Assert.True(queryResponse.Documents.Count() > 0, "documents.count is 0");
diff --git a/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs b/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs
index f92cb99e83e..7fb6a0ddb34 100644
--- a/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Indices/IndicesTests.cs
@@ -20,7 +20,7 @@ protected void TestDefaultAssertions(QueryResponse<ElasticsearchProject> queryRe
 		{
 			Assert.True(queryResponse.IsValid);
 			Assert.NotNull(queryResponse.ConnectionStatus);
-			Assert.Null(queryResponse.ConnectionStatus.Error);
+			Assert.Null(queryResponse.ConnectionStatus.OriginalException);
 			Assert.True(queryResponse.Total > 0, "No hits");
 			Assert.True(queryResponse.Documents.Any());
 			Assert.True(queryResponse.Documents.Count() > 0);
diff --git a/src/Tests/Nest.Tests.Integration/Indices/OpenCloseTests.cs b/src/Tests/Nest.Tests.Integration/Indices/OpenCloseTests.cs
index 4ecde991260..9ed46f1acb0 100644
--- a/src/Tests/Nest.Tests.Integration/Indices/OpenCloseTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Indices/OpenCloseTests.cs
@@ -38,8 +38,9 @@ public void CloseAndSearchAndOpenIndex()
 			);
 
 			Assert.False(results.IsValid);
-			Assert.IsNotNull(results.ConnectionStatus.Error);
-			Assert.True(results.ConnectionStatus.Error.HttpStatusCode == System.Net.HttpStatusCode.Forbidden, results.ConnectionStatus.Error.HttpStatusCode.ToString());
+			Assert.IsNotNull(results.ConnectionStatus);
+			var statusCode = results.ConnectionStatus.HttpStatusCode;
+			Assert.AreEqual(statusCode, 403);
 			var result = results.ConnectionStatus.ResponseRaw.Utf8String();
 			Assert.True(result.Contains("ClusterBlockException"));
 			Assert.True(result.Contains("index closed"));
diff --git a/src/Tests/Nest.Tests.Integration/IntegrationTests.cs b/src/Tests/Nest.Tests.Integration/IntegrationTests.cs
index 7ab238d03f5..696e94b273c 100644
--- a/src/Tests/Nest.Tests.Integration/IntegrationTests.cs
+++ b/src/Tests/Nest.Tests.Integration/IntegrationTests.cs
@@ -14,6 +14,7 @@ namespace Nest.Tests.Integration
 	public class IntegrationTests
 	{
 		protected readonly IElasticClient _client = ElasticsearchConfiguration.Client;
+		protected readonly IElasticClient _clientNoRawResponse = ElasticsearchConfiguration.ClientNoRawResponse;
 		protected readonly ElasticClient _thriftClient = ElasticsearchConfiguration.ThriftClient;
 		protected readonly IConnectionSettingsValues _settings = ElasticsearchConfiguration.Settings();
 	
diff --git a/src/Tests/Nest.Tests.Integration/RawCalls/ReturnTypesTest.cs b/src/Tests/Nest.Tests.Integration/RawCalls/ReturnTypesTest.cs
index 46a9c1e4b20..d135001dfec 100644
--- a/src/Tests/Nest.Tests.Integration/RawCalls/ReturnTypesTest.cs
+++ b/src/Tests/Nest.Tests.Integration/RawCalls/ReturnTypesTest.cs
@@ -10,10 +10,20 @@ namespace Nest.Tests.Integration.RawCalls
 	[TestFixture]
 	public class ReturnTypeTests : IntegrationTests
 	{
+		private IElasticClient _clientThatDoesNotExpose; 
+
+		public ReturnTypeTests()
+		{
+			var settings = ElasticsearchConfiguration.Settings()
+				.ExposeRawResponse(false);
+			_clientThatDoesNotExpose = new ElasticClient(settings);
+		}
+
+
 		[Test]
 		public void StringReturn()
 		{
-			var r = this._client.Raw.Info<string>();
+			var r = this._clientThatDoesNotExpose.Raw.Info<string>();
 			r.Response.Should().NotBeNullOrEmpty();
 			r.ResponseRaw.Should().BeNull();
 		}
@@ -21,7 +31,7 @@ public void StringReturn()
 		[Test]
 		public async void StringReturn_Async()
 		{
-			var r = await this._client.Raw.InfoAsync<string>();
+			var r = await this._clientThatDoesNotExpose.Raw.InfoAsync<string>();
 			r.Response.Should().NotBeNullOrEmpty();
 			r.ResponseRaw.Should().BeNull();
 		}
@@ -29,7 +39,7 @@ public async void StringReturn_Async()
 		[Test]
 		public void ByteArrayReturn()
 		{
-			var r = this._client.Raw.Info<byte[]>();
+			var r = this._clientThatDoesNotExpose.Raw.Info<byte[]>();
 			r.Response.Should().NotBeNull();
 			r.ResponseRaw.Should().BeNull();
 		}
@@ -37,14 +47,14 @@ public void ByteArrayReturn()
 		[Test]
 		public async void ByteArrayReturn_Async()
 		{
-			var r = await this._client.Raw.InfoAsync<byte[]>();
+			var r = await this._clientThatDoesNotExpose.Raw.InfoAsync<byte[]>();
 			r.Response.Should().NotBeNull();
 			r.ResponseRaw.Should().BeNull();
 		}
 		[Test]
 		public void VoidResponseReturn()
 		{
-			var r = this._client.Raw.Info<VoidResponse>();
+			var r = this._clientThatDoesNotExpose.Raw.Info<VoidResponse>();
 			r.Response.Should().BeNull();
 			r.ResponseRaw.Should().BeNull();
 		}
diff --git a/src/Tests/Nest.Tests.Integration/Search/QueryResponseMapperTests.cs b/src/Tests/Nest.Tests.Integration/Search/QueryResponseMapperTests.cs
index d198827c2ac..32dfdb8c077 100644
--- a/src/Tests/Nest.Tests.Integration/Search/QueryResponseMapperTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Search/QueryResponseMapperTests.cs
@@ -20,7 +20,7 @@ protected void TestDefaultAssertions(IQueryResponse<ElasticsearchProject> queryR
 		{
 			Assert.True(queryResponse.IsValid);
 			Assert.NotNull(queryResponse.ConnectionStatus);
-			Assert.Null(queryResponse.ConnectionStatus.Error);
+			Assert.Null(queryResponse.ConnectionStatus.OriginalException);
 			Assert.True(queryResponse.Total > 0, "No hits");
 			Assert.True(queryResponse.Documents.Any());
 			Assert.True(queryResponse.Documents.Count() > 0);
@@ -37,9 +37,8 @@ public void BogusQuery()
 				.QueryRaw("here be dragons")
 			);
 			Assert.False(queryResults.IsValid);
-			var error = queryResults.ConnectionStatus.Error;
-			Assert.NotNull(error);
-			Assert.True(error.HttpStatusCode == System.Net.HttpStatusCode.BadRequest, error.HttpStatusCode.ToString());
+			Assert.NotNull(queryResults.ConnectionStatus.HttpStatusCode);
+			Assert.AreEqual(queryResults.ConnectionStatus.HttpStatusCode, 400);
 		}
 
 		[Test]
diff --git a/src/Tests/Nest.Tests.Integration/Warmers/WarmersTests.cs b/src/Tests/Nest.Tests.Integration/Warmers/WarmersTests.cs
index 1c6193a2e28..e9aef301bca 100644
--- a/src/Tests/Nest.Tests.Integration/Warmers/WarmersTests.cs
+++ b/src/Tests/Nest.Tests.Integration/Warmers/WarmersTests.cs
@@ -132,7 +132,7 @@ public void Delete()
 			Assert.Pass("1.0 GA has a bug that does not return a 404 for missing warmers see #5155");
 
 			warmerResponse.IsValid.Should().BeFalse();
-			warmerResponse.ConnectionStatus.Error.HttpStatusCode.Should().Be(HttpStatusCode.NotFound);
+			warmerResponse.ConnectionStatus.HttpStatusCode.Should().Be(404);
 		}
 
 	}
diff --git a/src/Tests/Nest.Tests.Unit/Core/Validate/ValidateRequestTests.cs b/src/Tests/Nest.Tests.Unit/Core/Validate/ValidateRequestTests.cs
index 64a79c1bbbf..deeca57e72d 100644
--- a/src/Tests/Nest.Tests.Unit/Core/Validate/ValidateRequestTests.cs
+++ b/src/Tests/Nest.Tests.Unit/Core/Validate/ValidateRequestTests.cs
@@ -100,7 +100,7 @@ public void InferredForceQueryString()
 			var status = result.ConnectionStatus;
 			var uri = new Uri(status.RequestUrl);
 			Assert.AreEqual("/nest_test_data/elasticsearchprojects/_validate/query", uri.AbsolutePath);
-			Assert.AreEqual("?source=%7B%20match_all%20%3A%20%7B%7D%20%7D", uri.Query);
+			Assert.AreEqual("?source=%7B%20match_all%20:%20%7B%7D%20%7D", uri.Query);
 			StringAssert.AreEqualIgnoringCase("GET", status.RequestMethod);
 		}
 	}
diff --git a/src/Tests/Nest.Tests.Unit/Search/SearchOptions/SearchOptionTests.cs b/src/Tests/Nest.Tests.Unit/Search/SearchOptions/SearchOptionTests.cs
index f50cfb7fc16..be3b0e0a899 100644
--- a/src/Tests/Nest.Tests.Unit/Search/SearchOptions/SearchOptionTests.cs
+++ b/src/Tests/Nest.Tests.Unit/Search/SearchOptions/SearchOptionTests.cs
@@ -117,7 +117,7 @@ public void TestExecuteOnNode()
 				.Size(10)
 				.ExecuteOnNode("somenode");
 			var result = this._client.Search<ElasticsearchProject>(ss=>s);
-			StringAssert.Contains("preference=_only_node%3Asomenode", result.ConnectionStatus.RequestUrl);
+			StringAssert.Contains("preference=_only_node:somenode", result.ConnectionStatus.RequestUrl);
 		}
 		[Test]
 		public void TestExecuteOnPreferredNode()
@@ -127,7 +127,7 @@ public void TestExecuteOnPreferredNode()
 				.Size(10)
 				.ExecuteOnPreferredNode("somenode");
 			var result = this._client.Search<ElasticsearchProject>(ss=>s);
-			StringAssert.Contains("preference=_prefer_node%3Asomenode", result.ConnectionStatus.RequestUrl);
+			StringAssert.Contains("preference=_prefer_node:somenode", result.ConnectionStatus.RequestUrl);
 		}
 		[Test]
 		public void TestFields()

From 08dfa427d75cca87918ab77e66b1b4d784b0d29d Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Fri, 28 Mar 2014 21:38:03 +0100
Subject: [PATCH 03/20] fixed the yaml tests (_cat tests still broken but that
 will be fixed on a different branch)

---
 .../Domain/ElasticsearchDynamicValue.cs       |  5 ++-
 .../ElasticsearchDefaultSerializer.cs         |  2 +-
 .../YamlTestsBase.cs                          | 34 ++++++++++++++-----
 3 files changed, 31 insertions(+), 10 deletions(-)

diff --git a/src/Elasticsearch.Net/Domain/ElasticsearchDynamicValue.cs b/src/Elasticsearch.Net/Domain/ElasticsearchDynamicValue.cs
index b3a75539fa8..d5c0bd9e883 100644
--- a/src/Elasticsearch.Net/Domain/ElasticsearchDynamicValue.cs
+++ b/src/Elasticsearch.Net/Domain/ElasticsearchDynamicValue.cs
@@ -239,7 +239,10 @@ public override bool Equals(object compareValue)
 				return false;
 			}
 
-			if (ReferenceEquals(this, compareValue))
+			if (ReferenceEquals(this, compareValue)
+				|| ReferenceEquals(this.value, compareValue)
+				|| Equals(this.value, compareValue)
+				)
 			{
 				return true;
 			}
diff --git a/src/Elasticsearch.Net/Serialization/ElasticsearchDefaultSerializer.cs b/src/Elasticsearch.Net/Serialization/ElasticsearchDefaultSerializer.cs
index 03192c8cd5e..11cac3d65f4 100644
--- a/src/Elasticsearch.Net/Serialization/ElasticsearchDefaultSerializer.cs
+++ b/src/Elasticsearch.Net/Serialization/ElasticsearchDefaultSerializer.cs
@@ -23,7 +23,7 @@ public T Deserialize<T>(IElasticsearchResponse response, Stream stream, object d
 			{
 				stream.CopyTo(ms);
 				byte[] buffer = ms.ToArray();
-				if (buffer.Length == 0)
+				if (buffer.Length <= 1)
 					return default(T);
 				return SimpleJson.DeserializeObject<T>(buffer.Utf8String());
 			}
diff --git a/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs b/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
index 6208e65f602..9c00a9d5346 100644
--- a/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
+++ b/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Collections.Specialized;
 using System.Diagnostics;
 using System.Linq;
 using System.Net;
@@ -32,7 +33,7 @@ static YamlTestsBase()
 			if (Process.GetProcessesByName("fiddler").Any())
 				host = "ipv4.fiddler";
 			var uri = new Uri("http://"+host+":9200/");
-			var settings = new ConnectionConfiguration(uri).UsePrettyResponses();
+			var settings = new ConnectionConfiguration(uri).ExposeRawResponse();
 
 			var jsonNetSerializer = new ElasticsearchJsonNetSerializer();
 
@@ -319,11 +320,7 @@ protected void IsMatch(object o, object value)
 			else if (o is object[] || o is IList<object>)
 			{
 				var oo = (o as object[]) ?? (o as IList<object>);
-				var json = _client.Serializer.Serialize(value);
-				var otherJson = _client.Serializer.Serialize(oo);
-				var nJson = JArray.Parse(Encoding.UTF8.GetString(json)).ToString();
-				var nOtherJson = JArray.Parse(Encoding.UTF8.GetString(otherJson)).ToString();
-				Assert.AreEqual(nJson, nOtherJson);
+				SerializedArrayJsonEquals(value, oo);
 			}
 			else if (o is IDictionary<string, object>)
 			{
@@ -335,13 +332,34 @@ protected void IsMatch(object o, object value)
 							x => x.Name, 
 							x => (x.GetGetMethod().Invoke(value, null) ?? ""));
 
-				var equals = DynamicDictionary.Create(d)
-					.SequenceEqual(dd);
+				var ds = new SortedDictionary<string, object>(d);
+				var dds = new SortedDictionary<string, object>(dd);
+
+				var equals = DynamicDictionary.Create(ds).SequenceEqual(dds)
+					|| SerializedJsonEquals(dd,dds);
 				Assert.True(equals, "response did not match expected return");
 
 			}
 			else Assert.Fail(message);
 		}
+
+		private static void SerializedArrayJsonEquals(object value, object oo)
+		{
+			var json = _client.Serializer.Serialize(value);
+			var otherJson = _client.Serializer.Serialize(oo);
+			var nJson = JArray.Parse(Encoding.UTF8.GetString(json)).ToString();
+			var nOtherJson = JArray.Parse(Encoding.UTF8.GetString(otherJson)).ToString();
+			Assert.AreEqual(nJson, nOtherJson);
+		}
+		private static bool SerializedJsonEquals(object value, object oo)
+		{
+			var json = _client.Serializer.Serialize(value);
+			var otherJson = _client.Serializer.Serialize(oo);
+			var nJson = JObject.Parse(Encoding.UTF8.GetString(json)).ToString();
+			var nOtherJson = JObject.Parse(Encoding.UTF8.GetString(otherJson)).ToString();
+			Assert.AreEqual(nJson, nOtherJson);
+			return true;
+		}
 	}
 
 

From 9a873e1f3b8c49d3e0e3219834e072a0ead9886a Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Mon, 31 Mar 2014 10:45:15 +0200
Subject: [PATCH 04/20] fixed Elasticsearch.Net.Tests.Unit failing tests due to
 changed method signatures not reflected in the faked objectS

---
 src/Elasticsearch.Net/Connection/Transport.cs                | 2 +-
 .../Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs    | 5 +++--
 .../Connection/SkipDeadNodesTests.cs                         | 4 ++--
 .../Connection/SniffingConnectionPoolTests.cs                | 2 +-
 src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs    | 2 +-
 5 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index 4278b40a870..416d731c2ea 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -400,7 +400,7 @@ private Task<ElasticsearchResponse<T>> _deserializeAsyncToResponse<T>(Stream res
 				)
 			{
 				tcs.SetResult(cs);
-				return null;
+				return tcs.Task;
 			}
 			var customConverter = deserializationState as Func<IElasticsearchResponse, Stream, T>;
 			if (customConverter != null)
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs
index 9c2d5df2218..5100b569b8a 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs
@@ -108,8 +108,9 @@ public async void ShouldNotRetryOn400_Async()
 				fake.Provide<IConnectionConfigurationValues>(_connectionConfig);
 				FakeCalls.ProvideDefaultTransport(fake);
 				
-				var getCall = FakeCalls.GetCall(fake); 
-				getCall.Returns(Task.FromResult(FakeResponse.Any(_connectionConfig, 400)));
+				var getCall = FakeCalls.GetCall(fake);
+				var task = Task.FromResult(FakeResponse.Any(_connectionConfig, 400));
+				getCall.Returns(task);
 				
 				var client = fake.Resolve<ElasticsearchClient>();
 
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs
index 37bf67ead06..ecc9270f3b3 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs
@@ -49,7 +49,7 @@ public void DeadNodesAreNotVisited_AndPingedAppropiately()
 				);
 				
 				var seenNodes = new List<Uri>();
-				getCall.Invokes((Uri u, object o) => seenNodes.Add(u));
+				getCall.Invokes((Uri u, IConnectionConfigurationOverrides o) => seenNodes.Add(u));
 
 				var pingCall = FakeCalls.Ping(fake);
 				pingCall.Returns(true);
@@ -100,7 +100,7 @@ public async void DeadNodesAreNotVisited_AndPingedAppropiately_Async()
 				);
 				
 				var seenNodes = new List<Uri>();
-				getCall.Invokes((Uri u, object o) => seenNodes.Add(u));
+				getCall.Invokes((Uri u, IConnectionConfigurationOverrides o) => seenNodes.Add(u));
 
 				var pingCall = FakeCalls.Ping(fake);
 				pingCall.Returns(true);
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
index 554da31afbf..7863339eded 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
@@ -214,7 +214,7 @@ public void HostsReturnedBySniffAreVisited()
 					FakeResponse.Ok(config), //info 8
 					FakeResponse.Ok(config) //info 9
 				);
-				getCall.Invokes((Uri u, object o) => seenNodes.Add(u));
+				getCall.Invokes((Uri u, IConnectionConfigurationOverrides o) => seenNodes.Add(u));
 
 				fake.Provide<ITransport>(fake.Resolve<Transport>());
 				var client1 = fake.Resolve<ElasticsearchClient>();
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
index 228eb1ee976..a9baa9fb567 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
@@ -20,7 +20,7 @@ public static IReturnValueConfiguration<ElasticsearchResponse<Stream>> GetSyncCa
 		}
 		public static IReturnValueArgumentValidationConfiguration<Task<ElasticsearchResponse<Stream>>> GetCall(AutoFake fake)
 		{
-			return A.CallTo(() => fake.Resolve<IConnection>().Get(A<Uri>._, A<IConnectionConfigurationOverrides>._));
+			return A.CallTo(() => fake.Resolve<IConnection>().Get(A<Uri>._, null));
 		}
 
 		public static IReturnValueArgumentValidationConfiguration<bool> Ping(AutoFake fake)

From 25ca6a468c8750bba587ee087da0ec533cb1f929 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Mon, 31 Mar 2014 13:25:52 +0200
Subject: [PATCH 05/20] -Refactored Transport - No longer pass *QueryString to
 calls but *RequestParameters, more generic makes sense to also pass request
 specific settings as  such timeout

---
 .../ApiGenerator.cs                           |   18 +-
 .../CodeGeneration.LowLevelClient.csproj      |    4 +-
 .../Domain/ApiEndpoint.cs                     |    2 +-
 .../CodeGeneration.LowLevelClient/Program.cs  |    4 +-
 ...tml => RequestParameters.Generated.cshtml} |    2 +-
 ...uestParametersExtensions.Generated.cshtml} |    4 +-
 .../Connection/ITransport.cs                  |   10 +-
 src/Elasticsearch.Net/Connection/Transport.cs |  194 +-
 .../Domain/ElasticsearchResponse.cs           |    4 +
 ...ryString.cs => FluentRequestParameters.cs} |   22 +-
 ...ated.cs => RequestParameters.Generated.cs} | 1090 ++---
 .../Elasticsearch.Net.csproj                  |    4 +-
 .../ElasticsearchClient.Generated.cs          | 3648 ++++++++---------
 src/Elasticsearch.Net/ElasticsearchClient.cs  |    4 +-
 .../IElasticsearchClient.Generated.cs         | 1824 ++++-----
 src/Nest/DSL/AliasDescriptor.cs               |    6 +-
 src/Nest/DSL/AnalyzeDescriptor.cs             |    8 +-
 src/Nest/DSL/BulkDescriptor.cs                |    8 +-
 src/Nest/DSL/ClearCacheDescriptor.cs          |    8 +-
 src/Nest/DSL/CloseIndexDescriptor.cs          |    8 +-
 src/Nest/DSL/ClusterHealthDescriptor.cs       |    8 +-
 src/Nest/DSL/ClusterStateDescriptor.cs        |    8 +-
 src/Nest/DSL/CountDescriptor.cs               |    8 +-
 src/Nest/DSL/CreateIndexDescriptor.cs         |    6 +-
 src/Nest/DSL/DeleteByQueryDescriptor.cs       |    8 +-
 src/Nest/DSL/DeleteDescriptor.cs              |    8 +-
 src/Nest/DSL/DeleteIndexDescriptor.cs         |    8 +-
 src/Nest/DSL/DeleteMappingDescriptor.cs       |    8 +-
 src/Nest/DSL/DeleteTemplateDescriptor.cs      |    8 +-
 src/Nest/DSL/DeleteWarmerDescriptor.cs        |    8 +-
 src/Nest/DSL/FlushDescriptor.cs               |    8 +-
 src/Nest/DSL/GetAliasesDescriptor.cs          |    8 +-
 src/Nest/DSL/GetDescriptor.cs                 |    8 +-
 src/Nest/DSL/GetIndexSettingsDescriptor.cs    |    8 +-
 src/Nest/DSL/GetMappingDescriptor.cs          |    8 +-
 src/Nest/DSL/GetTemplateDescriptor.cs         |    8 +-
 src/Nest/DSL/GetWarmerDescriptor.cs           |    8 +-
 src/Nest/DSL/IndexDescriptor.cs               |    8 +-
 src/Nest/DSL/IndexExistsDescriptor.cs         |    8 +-
 src/Nest/DSL/IndicesStatsDescriptor.cs        |    8 +-
 src/Nest/DSL/IndicesStatusDescriptor.cs       |    8 +-
 src/Nest/DSL/InfoDescriptor.cs                |    6 +-
 src/Nest/DSL/MoreLikeThisDescriptor.cs        |    8 +-
 src/Nest/DSL/MultiGetDescriptor.cs            |    8 +-
 src/Nest/DSL/MultiSearchDescriptor.cs         |    8 +-
 src/Nest/DSL/NodesInfoDescriptor.cs           |    8 +-
 src/Nest/DSL/NodesStatsDescriptor.cs          |    8 +-
 src/Nest/DSL/OpenIndexDescriptor.cs           |    8 +-
 src/Nest/DSL/OptimizeDescriptor.cs            |    8 +-
 src/Nest/DSL/Paths/DocumentPathDescriptor.cs  |    4 +-
 .../DSL/Paths/FixedIndexTypePathDescriptor.cs |    4 +-
 src/Nest/DSL/Paths/IndexNamePathDescriptor.cs |    4 +-
 .../DSL/Paths/IndexOptionalPathDescriptor.cs  |    4 +-
 src/Nest/DSL/Paths/IndexPathDescriptor.cs     |    4 +-
 src/Nest/DSL/Paths/IndexTypePathDescriptor.cs |    4 +-
 .../DSL/Paths/IndexTypePathTypedDescriptor.cs |    4 +-
 ...ndicesOptionalExplicitAllPathDescriptor.cs |    4 +-
 .../Paths/IndicesOptionalPathDescriptor.cs    |    4 +-
 .../IndicesOptionalTypesNamePathDecriptor.cs  |    4 +-
 .../DSL/Paths/IndicesTypePathDescriptor.cs    |    4 +-
 src/Nest/DSL/Paths/NamePathDescriptor.cs      |    4 +-
 .../DSL/Paths/NodeIdOptionalDescriptor.cs     |    4 +-
 src/Nest/DSL/Paths/QueryPathDescriptor.cs     |   11 +-
 src/Nest/DSL/PercolateDescriptor.cs           |    8 +-
 src/Nest/DSL/PutMappingDescriptor.cs          |    8 +-
 src/Nest/DSL/PutTemplateDescriptor.cs         |    8 +-
 src/Nest/DSL/PutWarmerDescriptor.cs           |    8 +-
 src/Nest/DSL/RefreshDescriptor.cs             |    8 +-
 src/Nest/DSL/RegisterPercolatorDescriptor.cs  |    8 +-
 src/Nest/DSL/ScrollDescriptor.cs              |    8 +-
 src/Nest/DSL/SearchDescriptor.cs              |    6 +-
 src/Nest/DSL/SegmentsDescriptor.cs            |    8 +-
 src/Nest/DSL/SnapshotDescriptor.cs            |    8 +-
 src/Nest/DSL/SourceDescriptor.cs              |    8 +-
 .../DSL/UnregisterPercolatorDescriptor.cs     |    8 +-
 src/Nest/DSL/UpdateDescriptor.cs              |    8 +-
 src/Nest/DSL/UpdateSettingsDescriptor.cs      |    8 +-
 src/Nest/DSL/ValidateQueryDescriptor.cs       |    8 +-
 src/Nest/DSL/_Descriptors.generated.cs        |  181 +-
 src/Nest/Domain/DSL/IPathInfo.cs              |    2 +-
 .../Domain/Paths/ElasticSearchPathInfo.cs     |    2 +-
 ... RequestParametersExtensions.Generated.cs} |  100 +-
 src/Nest/ElasticClient-Aliases.cs             |    8 +-
 src/Nest/ElasticClient-Analyze.cs             |    4 +-
 src/Nest/ElasticClient-Bulk.cs                |    4 +-
 src/Nest/ElasticClient-ClearCache.cs          |    4 +-
 src/Nest/ElasticClient-ClusterHealth.cs       |    4 +-
 src/Nest/ElasticClient-Count.cs               |    4 +-
 src/Nest/ElasticClient-CreateIndex.cs         |    4 +-
 src/Nest/ElasticClient-Delete.cs              |    4 +-
 src/Nest/ElasticClient-DeleteByQuery.cs       |    4 +-
 src/Nest/ElasticClient-Flush.cs               |    4 +-
 src/Nest/ElasticClient-GatewaySnapshot.cs     |    4 +-
 src/Nest/ElasticClient-Get.cs                 |    4 +-
 src/Nest/ElasticClient-Index.cs               |    4 +-
 src/Nest/ElasticClient-IndexExists.cs         |    4 +-
 src/Nest/ElasticClient-MappingDelete.cs       |    4 +-
 src/Nest/ElasticClient-MappingGet.cs          |    4 +-
 src/Nest/ElasticClient-MappingIndex.cs        |    8 +-
 src/Nest/ElasticClient-MappingType.cs         |    4 +-
 src/Nest/ElasticClient-MoreLikeThis.cs        |   10 +-
 src/Nest/ElasticClient-MultiGet.cs            |    4 +-
 src/Nest/ElasticClient-MultiSearch.cs         |    4 +-
 src/Nest/ElasticClient-Nodes.cs               |    8 +-
 src/Nest/ElasticClient-OpenClose.cs           |    8 +-
 src/Nest/ElasticClient-Optimize.cs            |    4 +-
 src/Nest/ElasticClient-Percolate.cs           |   12 +-
 src/Nest/ElasticClient-Refresh.cs             |    4 +-
 src/Nest/ElasticClient-RootNodeInfo.cs        |    4 +-
 src/Nest/ElasticClient-Scroll.cs              |    4 +-
 src/Nest/ElasticClient-Search.cs              |    4 +-
 src/Nest/ElasticClient-Segments.cs            |    4 +-
 src/Nest/ElasticClient-Source.cs              |    4 +-
 src/Nest/ElasticClient-State.cs               |    4 +-
 src/Nest/ElasticClient-Stats.cs               |    4 +-
 src/Nest/ElasticClient-Status.cs              |    4 +-
 src/Nest/ElasticClient-Template.cs            |   12 +-
 src/Nest/ElasticClient-Update.cs              |    4 +-
 src/Nest/ElasticClient-UpdateSettings.cs      |    4 +-
 src/Nest/ElasticClient-Validate.cs            |    4 +-
 src/Nest/ElasticClient-Warmers.cs             |   12 +-
 src/Nest/ElasticClient.cs                     |    8 +-
 src/Nest/Nest.csproj                          |    2 +-
 src/Nest/RawDispatch.generated.cs             |  356 +-
 124 files changed, 4090 insertions(+), 4044 deletions(-)
 rename src/CodeGeneration/CodeGeneration.LowLevelClient/Views/{QueryStringParameters.Generated.cshtml => RequestParameters.Generated.cshtml} (94%)
 rename src/CodeGeneration/CodeGeneration.LowLevelClient/Views/{QueryStringParametersExtensions.Generated.cshtml => RequestParametersExtensions.Generated.cshtml} (93%)
 rename src/Elasticsearch.Net/Domain/{FluentQueryString.cs => FluentRequestParameters.cs} (51%)
 rename src/Elasticsearch.Net/Domain/{QueryStringParameters.Generated.cs => RequestParameters.Generated.cs} (76%)
 rename src/Nest/Domain/{QueryStringParametersExtensions.Generated.cs => RequestParametersExtensions.Generated.cs} (75%)

diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/ApiGenerator.cs b/src/CodeGeneration/CodeGeneration.LowLevelClient/ApiGenerator.cs
index 83dc14c673a..ffd7f1d253d 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/ApiGenerator.cs
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/ApiGenerator.cs
@@ -133,11 +133,11 @@ public static void PatchMethod(CsharpMethod method)
 				Regex.Replace(method.FullName, m, (a) => a.Index != method.FullName.IndexOf(m) ? "" : m);
 
 			string manualOverride;
-			var key = method.QueryStringParamName.Replace("QueryString", "");
+			var key = method.QueryStringParamName.Replace("RequestParameters", "");
 			if (MethodNameOverrides.TryGetValue(key, out manualOverride))
-				method.QueryStringParamName = manualOverride + "QueryString";
+				method.QueryStringParamName = manualOverride + "RequestParameters";
 
-			method.DescriptorType = method.QueryStringParamName.Replace("QueryString","Descriptor");
+			method.DescriptorType = method.QueryStringParamName.Replace("RequestParameters","Descriptor");
 
 			string generic;
 			if (KnownDescriptors.TryGetValue(method.DescriptorType, out generic))
@@ -195,17 +195,17 @@ public static void GenerateDescriptors(RestApiSpec model)
 			File.WriteAllText(targetFile, source);
 		}
 
-		public static void GenerateQueryStringParameters(RestApiSpec model)
+		public static void GenerateRequestParameters(RestApiSpec model)
 		{
-			var targetFile = _esNetFolder + @"Domain\QueryStringParameters.Generated.cs";
-			var source = _razorMachine.Execute(File.ReadAllText(_viewFolder + @"QueryStringParameters.Generated.cshtml"), model).ToString();
+			var targetFile = _esNetFolder + @"Domain\RequestParameters.Generated.cs";
+			var source = _razorMachine.Execute(File.ReadAllText(_viewFolder + @"RequestParameters.Generated.cshtml"), model).ToString();
 			File.WriteAllText(targetFile, source);
 		}
 
-		public static void GenerateQueryStringParametersExtensions(RestApiSpec model)
+		public static void GenerateRequestParametersExtensions(RestApiSpec model)
 		{
-			var targetFile = _nestFolder + @"Domain\QueryStringParametersExtensions.Generated.cs";
-			var source = _razorMachine.Execute(File.ReadAllText(_viewFolder + @"QueryStringParametersExtensions.Generated.cshtml"), model).ToString();
+			var targetFile = _nestFolder + @"Domain\RequestParametersExtensions.Generated.cs";
+			var source = _razorMachine.Execute(File.ReadAllText(_viewFolder + @"RequestParametersExtensions.Generated.cshtml"), model).ToString();
 			File.WriteAllText(targetFile, source);
 		}
 		public static void GenerateEnums(RestApiSpec model)
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.csproj b/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.csproj
index e1fe83df2bd..b12c74ff504 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.csproj
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.csproj
@@ -87,12 +87,12 @@
   <ItemGroup>
     <None Include="App.config" />
     <None Include="packages.config" />
-    <None Include="Views\QueryStringParametersExtensions.Generated.cshtml" />
+    <None Include="Views\RequestParametersExtensions.Generated.cshtml" />
     <None Include="Views\_Descriptors.Generated.cshtml" />
     <None Include="Views\RawDispatch.Generated.cshtml" />
     <None Include="Views\ElasticsearchClient.Generated.cshtml" />
     <None Include="Views\Enums.Generated.cshtml" />
-    <None Include="Views\QueryStringParameters.Generated.cshtml" />
+    <None Include="Views\RequestParameters.Generated.cshtml" />
     <None Include="Views\IElasticsearchClient.Generated.cshtml" />
   </ItemGroup>
   <ItemGroup>
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs b/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs
index 2972e339bc2..cc5914576a1 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs
@@ -145,7 +145,7 @@ public IEnumerable<CsharpMethod> CsharpMethods
 						{
 							this.Url.Params = new Dictionary<string, ApiQueryParameters>();
 						}
-						queryStringParamName = this.CsharpMethodName + "QueryString";
+						queryStringParamName = this.CsharpMethodName + "RequestParameters";
 						var paraIndent = "\r\n\t\t///";
 						var explanationOfT =
 							paraIndent + "<para> - If T is of type byte[] deserialization will be shortcircuited</para>"
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Program.cs b/src/CodeGeneration/CodeGeneration.LowLevelClient/Program.cs
index fecd3e42799..c59e7a3d5d0 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Program.cs
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Program.cs
@@ -15,8 +15,8 @@ static void Main(string[] args)
 
 			ApiGenerator.GenerateClientInterface(spec);
 
-			ApiGenerator.GenerateQueryStringParameters(spec);
-			ApiGenerator.GenerateQueryStringParametersExtensions(spec);
+			ApiGenerator.GenerateRequestParameters(spec);
+			ApiGenerator.GenerateRequestParametersExtensions(spec);
 			
 			ApiGenerator.GenerateDescriptors(spec);
 
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/QueryStringParameters.Generated.cshtml b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RequestParameters.Generated.cshtml
similarity index 94%
rename from src/CodeGeneration/CodeGeneration.LowLevelClient/Views/QueryStringParameters.Generated.cshtml
rename to src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RequestParameters.Generated.cshtml
index 409d33b2f92..bcceb23e739 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/QueryStringParameters.Generated.cshtml
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RequestParameters.Generated.cshtml
@@ -23,7 +23,7 @@ namespace Elasticsearch.Net
 	///@method.Documentation
 	///</pre>
 	///</summary>
-	public class @method.QueryStringParamName : FluentQueryString<@method.QueryStringParamName> 
+	public class @method.QueryStringParamName : FluentRequestParameters<@method.QueryStringParamName> 
 	{
 	  @foreach (KeyValuePair<string, ApiQueryParameters> kv in method.Url.Params)
 	  {
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/QueryStringParametersExtensions.Generated.cshtml b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RequestParametersExtensions.Generated.cshtml
similarity index 93%
rename from src/CodeGeneration/CodeGeneration.LowLevelClient/Views/QueryStringParametersExtensions.Generated.cshtml
rename to src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RequestParametersExtensions.Generated.cshtml
index b1d98b78937..749b7665e4c 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/QueryStringParametersExtensions.Generated.cshtml
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RequestParametersExtensions.Generated.cshtml
@@ -12,13 +12,13 @@ using System.Linq.Expressions;
 using Elasticsearch.Net;
 using Nest.Resolvers;
 
-///This file contains all the typed querystring parameters that are generated of the client spec.
+///This file contains all the typed request parameters that are generated of the client spec.
 ///This file is automatically generated from https://github.com/elasticsearch/elasticsearch-rest-api-spec
 ///Generated of commit @Model.Commit
 
 namespace Nest
 {
-	public static class QueryStringPameterExtensions
+	public static class RequestPameterExtensions
 	{
 	@foreach (CsharpMethod method in Model.CsharpMethodsWithQueryStringInfo)
 	{
diff --git a/src/Elasticsearch.Net/Connection/ITransport.cs b/src/Elasticsearch.Net/Connection/ITransport.cs
index 073b4175c8a..7692ce8f5c6 100644
--- a/src/Elasticsearch.Net/Connection/ITransport.cs
+++ b/src/Elasticsearch.Net/Connection/ITransport.cs
@@ -14,10 +14,8 @@ ElasticsearchResponse<T> DoRequest<T>(
 			string path, 
 			object data = null, 
 			NameValueCollection queryString = null, 
-			object serializationState = null,
-			int retried = 0, 
-			int? seed = null
-			);
+			object serializationState = null);
+
 		void Sniff(bool fromStartup = false);
 
 		Task<ElasticsearchResponse<T>> DoRequestAsync<T>(
@@ -25,9 +23,7 @@ Task<ElasticsearchResponse<T>> DoRequestAsync<T>(
 			string path, 
 			object data = null, 
 			NameValueCollection queryString = null,
-			object serializationState = null,
-			int retried = 0, 
-			int? seed = null);
+			object serializationState = null);
 	}
 
 	public interface ITransportValues
diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index 416d731c2ea..b9241083ed2 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -5,6 +5,8 @@
 using System.Linq;
 using System.Net;
 using System.Security.Cryptography;
+using System.Security.Cryptography.X509Certificates;
+using System.Threading;
 using System.Threading.Tasks;
 using Elasticsearch.Net.ConnectionPool;
 using Elasticsearch.Net.Exceptions;
@@ -14,15 +16,41 @@
 
 namespace Elasticsearch.Net.Connection
 {
+
+	class TransportRequestState<T>
+	{
+		public string Method { get; private set; }
+		public string Path { get; private set; }
+		public byte[] PostData { get; private set; }
+		public ElasticsearchResponseTracer<T> Tracer { get; private set; }
+		public object DeserializationState { get; private set; }
+
+		public int Retried { get; set; }
+		public int? Seed { get; set; }
+
+
+		public TransportRequestState(ElasticsearchResponseTracer<T> tracer, string method, string path, byte[] postData = null, NameValueCollection queryString = null, object deserializationState = null)
+		{
+			this.Method = method;
+			this.Path = path;
+			this.PostData = postData;
+			if (queryString != null) this.Path += queryString.ToQueryString();
+			this.DeserializationState = deserializationState;
+
+			this.Tracer = tracer;
+		}
+	}
+
 	public class Transport : ITransport
 	{
+		protected static readonly string MaxRetryExceptionMessage = "Unable to perform request: '{0} {1}' on any of the nodes after retrying {2} times.";
 		protected internal readonly IConnectionConfigurationValues _configurationValues;
 		protected internal readonly IConnection _connection;
 		protected internal readonly IElasticsearchSerializer _serializer;
 
 		private readonly IConnectionPool _connectionPool;
-		private IDateTimeProvider _dateTimeProvider;
-		private DateTime? _lastSniff = null;
+		private readonly IDateTimeProvider _dateTimeProvider;
+		private DateTime? _lastSniff;
 
 		public IConnectionConfigurationValues Settings { get { return _configurationValues; } }
 		public IElasticsearchSerializer Serializer { get { return _serializer; } }
@@ -39,7 +67,6 @@ public Transport(
 			this._serializer = serializer ?? new ElasticsearchDefaultSerializer();
 			this._connectionPool = this._configurationValues.ConnectionPool;
 
-			//TODO: take the datetimeprovider from the connection pool?
 			this._dateTimeProvider = dateTimeProvider ?? new DateTimeProvider();
 
 			this._lastSniff = this._dateTimeProvider.Now();
@@ -68,36 +95,43 @@ private int GetMaximumRetries()
 			return this._configurationValues.MaxRetries.GetValueOrDefault(this._connectionPool.MaxRetries);
 		}
 
-		public ElasticsearchResponse<T> DoRequest<T>(
-			string method,
-			string path,
-			object data = null,
-			NameValueCollection queryString = null,
-			object deserializationState = null,
-			int retried = 0,
-			int? seed = null)
+		/* SYNC *** */
+		public ElasticsearchResponse<T> DoRequest<T>(string method, string path, object data = null, NameValueCollection queryString = null, object deserializationState = null)
 		{
-			SniffIfInformationIsTooOld(retried);
+			using (var tracer = new ElasticsearchResponseTracer<T>(this.Settings.TraceEnabled))
+			{
+				var postData = PostData(data);
+				var requestState = new TransportRequestState<T>(tracer, method, path, postData, queryString, deserializationState);
+
+				var result = this.DoRequest<T>(requestState);
+				tracer.SetResult(result);
+				return result;
+			}
+		}
 
-			if (queryString != null) path += queryString.ToQueryString();
+		private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestState, int retried = 0)
+		{
+			SniffIfInformationIsTooOld(requestState.Retried);
 
-			var postData = PostData(data);
 			IElasticsearchResponse response = null;
 
 			int initialSeed; bool shouldPingHint;
-			var baseUri = this._connectionPool.GetNext(seed, out initialSeed, out shouldPingHint);
-			bool seenError = false;
+			var baseUri = this._connectionPool.GetNext(requestState.Seed, out initialSeed, out shouldPingHint);
+			requestState.Seed = initialSeed;
 
+			var uri = CreateUriToPath(baseUri, requestState.Path);
+			bool seenError = false;
+			
 			try
 			{
 				if (shouldPingHint && !this._configurationValues.DisablePings)
 					this._connection.Ping(CreateUriToPath(baseUri, ""));
 
-				var uri = CreateUriToPath(baseUri, path);
-				var streamResponse = _doRequest(method, uri, postData, null);
+				var streamResponse = _doRequest(requestState.Method, uri, requestState.PostData, null);
 				if (streamResponse != null && streamResponse.SuccessOrKnownError)
 				{
-					var typedResponse = this.StreamToTypedResponse<T>(streamResponse, deserializationState);
+					var typedResponse = this.StreamToTypedResponse<T>(streamResponse, requestState.DeserializationState);
+					typedResponse.NumberOfRetries = retried;
 					response = typedResponse;
 					return typedResponse;
 				}
@@ -108,7 +142,7 @@ public ElasticsearchResponse<T> DoRequest<T>(
 				if (maxRetries == 0 && retried == 0)
 					throw;
 				seenError = true;
-				return RetryRequest<T>(method, path, data, deserializationState, retried, baseUri, initialSeed, e);
+				return RetryRequest<T>(requestState, uri, retried, e);
 			}
 			finally
 			{
@@ -116,63 +150,67 @@ public ElasticsearchResponse<T> DoRequest<T>(
 				if (!seenError && response != null && response.SuccessOrKnownError)
 					this._connectionPool.MarkAlive(baseUri);
 			}
-			return RetryRequest<T>(method, path, data, deserializationState, retried, baseUri, initialSeed, null);
+			return RetryRequest<T>(requestState, uri, retried);
 		}
 
-		private ElasticsearchResponse<T> RetryRequest<T>(
-			string method, string path, object data, object deserializationState, int retried, Uri baseUri,
-			int initialSeed, Exception e)
+		private ElasticsearchResponse<T> RetryRequest<T>(TransportRequestState<T> requestState, Uri baseUri, int retried, Exception e = null)
 		{
 			var maxRetries = this.GetMaximumRetries();
-			var exceptionMessage = "Unable to perform request: '{0} {1}' on any of the nodes after retrying {2} times."
-				.F(method, path.IsNullOrEmpty() ? "/" : "", retried);
+			var exceptionMessage = MaxRetryExceptionMessage.F(requestState.Method, requestState.Path.IsNullOrEmpty() ? "/" : "", retried);
+
 			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);
 			if (this._configurationValues.SniffsOnConnectionFault && retried == 0)
 				this.Sniff();
 
-			if (retried < maxRetries)
-			{
-				return this.DoRequest<T>(method, path, data, null, deserializationState, ++retried, initialSeed);
-			}
-			throw new MaxRetryException(exceptionMessage, e);
+			if (retried >= maxRetries) throw new MaxRetryException(exceptionMessage, e);
+
+			return this.DoRequest<T>(requestState, ++retried);
 		}
 
 		private ElasticsearchResponse<Stream> _doRequest(string method, Uri uri, byte[] postData, IConnectionConfigurationOverrides requestSpecificConfig)
 		{
 			switch (method.ToLowerInvariant())
 			{
-				case "post":
-					return this._connection.PostSync(uri, postData, requestSpecificConfig);
-				case "put":
-					return this._connection.PutSync(uri, postData, requestSpecificConfig);
+				case "post": return this._connection.PostSync(uri, postData, requestSpecificConfig);
+				case "put": return this._connection.PutSync(uri, postData, requestSpecificConfig);
+				case "head": return this._connection.HeadSync(uri, requestSpecificConfig);
+				case "get": return this._connection.GetSync(uri, requestSpecificConfig);
 				case "delete":
 					return postData == null || postData.Length == 0
 						? this._connection.DeleteSync(uri, requestSpecificConfig)
 						: this._connection.DeleteSync(uri, postData, requestSpecificConfig);
-				case "head":
-					return this._connection.HeadSync(uri, requestSpecificConfig);
-				case "get":
-					return this._connection.GetSync(uri, requestSpecificConfig);
 			}
 			throw new Exception("Unknown HTTP method " + method);
 		}
 
-		public Task<ElasticsearchResponse<T>> DoRequestAsync<T>(
-			string method,
-			string path,
-			object data = null,
-			NameValueCollection queryString = null,
-			object deserializationState = null,
-			int retried = 0,
-			int? seed = null)
+
+		/* ASYNC *** */
+		public Task<ElasticsearchResponse<T>> DoRequestAsync<T>(string method, string path, object data = null, NameValueCollection queryString = null, object deserializationState = null)
 		{
-			SniffIfInformationIsTooOld(retried);
+			using (var tracer = new ElasticsearchResponseTracer<T>(this.Settings.TraceEnabled))
+			{
+				var postData = PostData(data);
+				var requestState = new TransportRequestState<T>(tracer, method, path, postData, queryString, deserializationState);
 
-			if (queryString != null) path += queryString.ToQueryString();
+				return this.DoRequestAsync<T>(requestState)
+					.ContinueWith(t =>
+					{
+						requestState.Tracer.SetResult(t.Result);
+						return t;
+					}).Unwrap();
+			}
+		}
 
-			var postData = PostData(data);
+		private Task<ElasticsearchResponse<T>> DoRequestAsync<T>(TransportRequestState<T> requestState, int retried = 0)
+		{
+			SniffIfInformationIsTooOld(retried);
+		
 			int initialSeed; bool shouldPingHint;
-			var baseUri = this._connectionPool.GetNext(seed, out initialSeed, out shouldPingHint);
+			var baseUri = this._connectionPool.GetNext(requestState.Seed, out initialSeed, out shouldPingHint);
+			requestState.Seed = initialSeed;
+
+			var uri = CreateUriToPath(baseUri, requestState.Path);
+			
 			if (shouldPingHint && !this._configurationValues.DisablePings)
 			{
 				try
@@ -181,37 +219,41 @@ public Task<ElasticsearchResponse<T>> DoRequestAsync<T>(
 				}
 				catch (Exception e)
 				{
-					return this.RetryRequestAsync<T>(method, path, data, deserializationState, retried, baseUri, initialSeed, e);
+					return this.RetryRequestAsync<T>(requestState, baseUri, retried, e);
 				}
 			}
-			var uri = CreateUriToPath(baseUri, path);
 			
-			return _doRequestAsync(method, uri, postData, null).ContinueWith(t =>
+			return _doRequestAsync(requestState.Method, uri, requestState.PostData, null).ContinueWith(t =>
 			{
 				if (t.IsCanceled)
 					return null;
 				if (t.IsFaulted)
-					return this.RetryRequestAsync<T>(method, path, data, deserializationState, retried, baseUri, initialSeed, t.Exception);
+					return this.RetryRequestAsync<T>(requestState, baseUri, retried, t.Exception);
 				if (t.Result.SuccessOrKnownError)
-					return this.StreamToTypedResponseAsync<T>(t.Result, deserializationState);
-				return this.RetryRequestAsync<T>(method, path, data, deserializationState, retried, baseUri, initialSeed, null);
+					return this.StreamToTypedResponseAsync<T>(t.Result, requestState.DeserializationState)
+						.ContinueWith(tt =>
+						{
+							tt.Result.NumberOfRetries = retried;
+							return tt;
+						}).Unwrap();
+				return this.RetryRequestAsync<T>(requestState, baseUri, retried);
 
 			}).Unwrap();
 		}
-		private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(
-			string method, string path, object data, object deserializationState, int retried, Uri baseUri,
-			int initialSeed, Exception e)
+
+		private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(TransportRequestState<T> requestState, Uri baseUri, int retried, Exception e = null)
 		{
 			var maxRetries = this.GetMaximumRetries();
-			var exceptionMessage = "Unable to perform request: '{0} {1}' on any of the nodes after retrying {2} times."
-				.F(method, path, retried);
+			var exceptionMessage = MaxRetryExceptionMessage.F(requestState.Method, requestState.Path, retried);
+
 			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);
+
 			if (this._configurationValues.SniffsOnConnectionFault && retried == 0)
 				this.Sniff();
+
 			if (retried < maxRetries)
-			{
-				return this.DoRequestAsync<T>(method, path, data, null, deserializationState, ++retried, initialSeed);
-			}
+				return this.DoRequestAsync<T>(requestState, ++retried);
+			
 			throw new MaxRetryException(exceptionMessage, e);
 		}
 
@@ -219,18 +261,14 @@ private Task<ElasticsearchResponse<Stream>> _doRequestAsync(string method, Uri u
 		{
 			switch (method.ToLowerInvariant())
 			{
-				case "post":
-					return this._connection.Post(uri, postData, requestSpecificConfig);
-				case "put":
-					return this._connection.Put(uri, postData, requestSpecificConfig);
+				case "head": return this._connection.Head(uri, requestSpecificConfig);
+				case "get": return this._connection.Get(uri, requestSpecificConfig);
+				case "post": return this._connection.Post(uri, postData, requestSpecificConfig);
+				case "put": return this._connection.Put(uri, postData, requestSpecificConfig);
 				case "delete":
 					return postData == null || postData.Length == 0
 						? this._connection.Delete(uri, requestSpecificConfig)
 						: this._connection.Delete(uri, postData, requestSpecificConfig);
-				case "head":
-					return this._connection.Head(uri, requestSpecificConfig);
-				case "get":
-					return this._connection.Get(uri, requestSpecificConfig);
 			}
 			throw new Exception("Unknown HTTP method " + method);
 		}
@@ -270,12 +308,12 @@ private byte[] PostData(object data)
 			return joined.Utf8Bytes();
 		}
 
-		public void SetStringResult(ElasticsearchResponse<string> response, byte[] rawResponse)
+		private void SetStringResult(ElasticsearchResponse<string> response, byte[] rawResponse)
 		{
 			response.Response = rawResponse.Utf8String();
 		}
 
-		public void SetByteResult(ElasticsearchResponse<byte[]> response, byte[] rawResponse)
+		private void SetByteResult(ElasticsearchResponse<byte[]> response, byte[] rawResponse)
 		{
 			response.Response = rawResponse;
 		}
@@ -316,7 +354,7 @@ private ElasticsearchResponse<T> StreamToTypedResponse<T>(ElasticsearchResponse<
 			}
 		}
 
-		private Task<ElasticsearchResponse<T>> StreamToTypedResponseAsync<T>(ElasticsearchResponse<Stream> streamResponse, object deserializationState)
+		private Task<ElasticsearchResponse<T>> StreamToTypedResponseAsync<T>(ElasticsearchResponse<Stream> streamResponse,  object deserializationState)
 		{
 			var tcs = new TaskCompletionSource<ElasticsearchResponse<T>>();
 
@@ -422,7 +460,7 @@ private Task<ElasticsearchResponse<T>> _deserializeAsyncToResponse<T>(Stream res
 		}
 
 		const int BUFFER_SIZE = 4096;
-		public IEnumerable<Task<MemoryStream>> ReadStreamAsync(Stream responseStream, MemoryStream memoryStream)
+		private IEnumerable<Task<MemoryStream>> ReadStreamAsync(Stream responseStream, MemoryStream memoryStream)
 		{
 			var buffer = new byte[BUFFER_SIZE];
 			try
@@ -442,7 +480,7 @@ public IEnumerable<Task<MemoryStream>> ReadStreamAsync(Stream responseStream, Me
 			}
 		}
 
-		public Task<MemoryStream> Iterate(IEnumerable<Task> asyncIterator, MemoryStream memoryStream)
+		private Task<MemoryStream> Iterate(IEnumerable<Task> asyncIterator, MemoryStream memoryStream)
 		{
 			var tcs = new TaskCompletionSource<MemoryStream>();
 			var enumerator = asyncIterator.GetEnumerator();
diff --git a/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs b/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
index 1ce7bd408e2..7b21ca544ef 100644
--- a/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
+++ b/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
@@ -31,6 +31,7 @@ public interface IElasticsearchResponse
 		[DebuggerDisplay("{Request != null ? System.Text.Encoding.UTF8.GetString(Request) : null,nq}")]
 		byte[] Request { get; }
 		int? HttpStatusCode { get; }
+		int NumberOfRetries { get; }
 
 		/// <summary>
 		/// The raw byte response, only set when IncludeRawResponse() is set on Connection configuration
@@ -67,6 +68,7 @@ public static ElasticsearchResponse<TTo> CloneFrom<TTo>(IElasticsearchResponse f
 				Serializer = from.Settings.Serializer,
 				Settings = from.Settings,
 				Success = from.Success
+				
 			};
 		}
 
@@ -96,6 +98,8 @@ public class ElasticsearchResponse<T> : IElasticsearchResponse
 
 		public byte[] Request { get; protected internal set; }
 
+		public int NumberOfRetries { get; protected internal set; }
+
 		/// <summary>
 		/// The raw byte response, only set when IncludeRawResponse() is set on Connection configuration
 		/// </summary>
diff --git a/src/Elasticsearch.Net/Domain/FluentQueryString.cs b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
similarity index 51%
rename from src/Elasticsearch.Net/Domain/FluentQueryString.cs
rename to src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
index da12cfc8de7..e77df0d84f3 100644
--- a/src/Elasticsearch.Net/Domain/FluentQueryString.cs
+++ b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
@@ -3,6 +3,7 @@
 using System.Collections.Specialized;
 using System.Linq;
 using System.Text;
+using Elasticsearch.Net.Connection;
 
 namespace Elasticsearch.Net
 {
@@ -11,13 +12,28 @@ namespace Elasticsearch.Net
 	/// You can always pass a simple NameValueCollection if you want.
 	/// </summary>
 	/// <typeparam name="T"></typeparam>
-	public abstract class FluentQueryString<T> where T : FluentQueryString<T>
+	public abstract class FluentRequestParameters<T> where T : FluentRequestParameters<T>
 	{
 		internal readonly IDictionary<string, object> _QueryStringDictionary = new Dictionary<string, object>();
+		
+		internal object _DeserializationState = null;
+
+		internal IConnectionConfigurationOverrides _RequestConfiguration = null;
 
 		public T Add(string name, object value)
 		{
-			_QueryStringDictionary[name] = value;
+			this._QueryStringDictionary[name] = value;
+			return (T)this;
+		}
+
+		public T RequestConfiguration(IConnectionConfigurationOverrides requestConfiguration)
+		{
+			this._RequestConfiguration = requestConfiguration;
+			return (T)this;
+		}
+		public T DeserializationState(object deserializationState)
+		{
+			_DeserializationState = deserializationState;
 			return (T)this;
 		}
 
@@ -28,7 +44,7 @@ public bool ContainsKey(string name)
 
 	}
 
-	public class FluentQueryString : FluentQueryString<FluentQueryString>
+	public class FluentRequestParameters : FluentRequestParameters<FluentRequestParameters>
 	{
 
 	}
diff --git a/src/Elasticsearch.Net/Domain/QueryStringParameters.Generated.cs b/src/Elasticsearch.Net/Domain/RequestParameters.Generated.cs
similarity index 76%
rename from src/Elasticsearch.Net/Domain/QueryStringParameters.Generated.cs
rename to src/Elasticsearch.Net/Domain/RequestParameters.Generated.cs
index d3a60e1f5b0..02f565db6a3 100644
--- a/src/Elasticsearch.Net/Domain/QueryStringParameters.Generated.cs
+++ b/src/Elasticsearch.Net/Domain/RequestParameters.Generated.cs
@@ -18,12 +18,12 @@ namespace Elasticsearch.Net
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html
 	///</pre>
 	///</summary>
-	public class BulkQueryString : FluentQueryString<BulkQueryString> 
+	public class BulkRequestParameters : FluentRequestParameters<BulkRequestParameters> 
 	{
 		
 		internal ConsistencyOptions _consistency { get; set; }
 		///<summary>Explicit write consistency setting for the operation</summary>
-		public BulkQueryString Consistency(ConsistencyOptions consistency)
+		public BulkRequestParameters Consistency(ConsistencyOptions consistency)
 		{
 			this._consistency = consistency;
 			this.Add("consistency", this._consistency);
@@ -33,7 +33,7 @@ public BulkQueryString Consistency(ConsistencyOptions consistency)
 		
 		internal bool _refresh { get; set; }
 		///<summary>Refresh the index after performing the operation</summary>
-		public BulkQueryString Refresh(bool refresh)
+		public BulkRequestParameters Refresh(bool refresh)
 		{
 			this._refresh = refresh;
 			this.Add("refresh", this._refresh);
@@ -43,7 +43,7 @@ public BulkQueryString Refresh(bool refresh)
 		
 		internal ReplicationOptions _replication { get; set; }
 		///<summary>Explicitely set the replication type</summary>
-		public BulkQueryString Replication(ReplicationOptions replication)
+		public BulkRequestParameters Replication(ReplicationOptions replication)
 		{
 			this._replication = replication;
 			this.Add("replication", this._replication);
@@ -53,7 +53,7 @@ public BulkQueryString Replication(ReplicationOptions replication)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public BulkQueryString Routing(string routing)
+		public BulkRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -63,7 +63,7 @@ public BulkQueryString Routing(string routing)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public BulkQueryString Timeout(string timeout)
+		public BulkRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -73,7 +73,7 @@ public BulkQueryString Timeout(string timeout)
 		
 		internal string _type { get; set; }
 		///<summary>Default document type for items which don&#39;t provide one</summary>
-		public BulkQueryString Type(string type)
+		public BulkRequestParameters Type(string type)
 		{
 			this._type = type;
 			this.Add("type", this._type);
@@ -88,12 +88,12 @@ public BulkQueryString Type(string type)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html
 	///</pre>
 	///</summary>
-	public class CatAliasesQueryString : FluentQueryString<CatAliasesQueryString> 
+	public class CatAliasesRequestParameters : FluentRequestParameters<CatAliasesRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatAliasesQueryString Local(bool local)
+		public CatAliasesRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -103,7 +103,7 @@ public CatAliasesQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatAliasesQueryString MasterTimeout(string master_timeout)
+		public CatAliasesRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -113,7 +113,7 @@ public CatAliasesQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatAliasesQueryString H(params string[] h)
+		public CatAliasesRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -123,7 +123,7 @@ public CatAliasesQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatAliasesQueryString Help(bool help)
+		public CatAliasesRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -133,7 +133,7 @@ public CatAliasesQueryString Help(bool help)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatAliasesQueryString V(bool v)
+		public CatAliasesRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -148,12 +148,12 @@ public CatAliasesQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html
 	///</pre>
 	///</summary>
-	public class CatAllocationQueryString : FluentQueryString<CatAllocationQueryString> 
+	public class CatAllocationRequestParameters : FluentRequestParameters<CatAllocationRequestParameters> 
 	{
 		
 		internal BytesOptions _bytes { get; set; }
 		///<summary>The unit in which to display byte values</summary>
-		public CatAllocationQueryString Bytes(BytesOptions bytes)
+		public CatAllocationRequestParameters Bytes(BytesOptions bytes)
 		{
 			this._bytes = bytes;
 			this.Add("bytes", this._bytes);
@@ -163,7 +163,7 @@ public CatAllocationQueryString Bytes(BytesOptions bytes)
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatAllocationQueryString Local(bool local)
+		public CatAllocationRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -173,7 +173,7 @@ public CatAllocationQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatAllocationQueryString MasterTimeout(string master_timeout)
+		public CatAllocationRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -183,7 +183,7 @@ public CatAllocationQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatAllocationQueryString H(params string[] h)
+		public CatAllocationRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -193,7 +193,7 @@ public CatAllocationQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatAllocationQueryString Help(bool help)
+		public CatAllocationRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -203,7 +203,7 @@ public CatAllocationQueryString Help(bool help)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatAllocationQueryString V(bool v)
+		public CatAllocationRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -218,12 +218,12 @@ public CatAllocationQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html
 	///</pre>
 	///</summary>
-	public class CatCountQueryString : FluentQueryString<CatCountQueryString> 
+	public class CatCountRequestParameters : FluentRequestParameters<CatCountRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatCountQueryString Local(bool local)
+		public CatCountRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -233,7 +233,7 @@ public CatCountQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatCountQueryString MasterTimeout(string master_timeout)
+		public CatCountRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -243,7 +243,7 @@ public CatCountQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatCountQueryString H(params string[] h)
+		public CatCountRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -253,7 +253,7 @@ public CatCountQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatCountQueryString Help(bool help)
+		public CatCountRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -263,7 +263,7 @@ public CatCountQueryString Help(bool help)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatCountQueryString V(bool v)
+		public CatCountRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -278,12 +278,12 @@ public CatCountQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-health.html
 	///</pre>
 	///</summary>
-	public class CatHealthQueryString : FluentQueryString<CatHealthQueryString> 
+	public class CatHealthRequestParameters : FluentRequestParameters<CatHealthRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatHealthQueryString Local(bool local)
+		public CatHealthRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -293,7 +293,7 @@ public CatHealthQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatHealthQueryString MasterTimeout(string master_timeout)
+		public CatHealthRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -303,7 +303,7 @@ public CatHealthQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatHealthQueryString H(params string[] h)
+		public CatHealthRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -313,7 +313,7 @@ public CatHealthQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatHealthQueryString Help(bool help)
+		public CatHealthRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -323,7 +323,7 @@ public CatHealthQueryString Help(bool help)
 		
 		internal bool _ts { get; set; }
 		///<summary>Set to false to disable timestamping</summary>
-		public CatHealthQueryString Ts(bool ts)
+		public CatHealthRequestParameters Ts(bool ts)
 		{
 			this._ts = ts;
 			this.Add("ts", this._ts);
@@ -333,7 +333,7 @@ public CatHealthQueryString Ts(bool ts)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatHealthQueryString V(bool v)
+		public CatHealthRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -348,12 +348,12 @@ public CatHealthQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat.html
 	///</pre>
 	///</summary>
-	public class CatHelpQueryString : FluentQueryString<CatHelpQueryString> 
+	public class CatHelpRequestParameters : FluentRequestParameters<CatHelpRequestParameters> 
 	{
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatHelpQueryString Help(bool help)
+		public CatHelpRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -368,12 +368,12 @@ public CatHelpQueryString Help(bool help)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html
 	///</pre>
 	///</summary>
-	public class CatIndicesQueryString : FluentQueryString<CatIndicesQueryString> 
+	public class CatIndicesRequestParameters : FluentRequestParameters<CatIndicesRequestParameters> 
 	{
 		
 		internal BytesOptions _bytes { get; set; }
 		///<summary>The unit in which to display byte values</summary>
-		public CatIndicesQueryString Bytes(BytesOptions bytes)
+		public CatIndicesRequestParameters Bytes(BytesOptions bytes)
 		{
 			this._bytes = bytes;
 			this.Add("bytes", this._bytes);
@@ -383,7 +383,7 @@ public CatIndicesQueryString Bytes(BytesOptions bytes)
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatIndicesQueryString Local(bool local)
+		public CatIndicesRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -393,7 +393,7 @@ public CatIndicesQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatIndicesQueryString MasterTimeout(string master_timeout)
+		public CatIndicesRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -403,7 +403,7 @@ public CatIndicesQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatIndicesQueryString H(params string[] h)
+		public CatIndicesRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -413,7 +413,7 @@ public CatIndicesQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatIndicesQueryString Help(bool help)
+		public CatIndicesRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -423,7 +423,7 @@ public CatIndicesQueryString Help(bool help)
 		
 		internal bool _pri { get; set; }
 		///<summary>Set to true to return stats only for primary shards</summary>
-		public CatIndicesQueryString Pri(bool pri)
+		public CatIndicesRequestParameters Pri(bool pri)
 		{
 			this._pri = pri;
 			this.Add("pri", this._pri);
@@ -433,7 +433,7 @@ public CatIndicesQueryString Pri(bool pri)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatIndicesQueryString V(bool v)
+		public CatIndicesRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -448,12 +448,12 @@ public CatIndicesQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-master.html
 	///</pre>
 	///</summary>
-	public class CatMasterQueryString : FluentQueryString<CatMasterQueryString> 
+	public class CatMasterRequestParameters : FluentRequestParameters<CatMasterRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatMasterQueryString Local(bool local)
+		public CatMasterRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -463,7 +463,7 @@ public CatMasterQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatMasterQueryString MasterTimeout(string master_timeout)
+		public CatMasterRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -473,7 +473,7 @@ public CatMasterQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatMasterQueryString H(params string[] h)
+		public CatMasterRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -483,7 +483,7 @@ public CatMasterQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatMasterQueryString Help(bool help)
+		public CatMasterRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -493,7 +493,7 @@ public CatMasterQueryString Help(bool help)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatMasterQueryString V(bool v)
+		public CatMasterRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -508,12 +508,12 @@ public CatMasterQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-nodes.html
 	///</pre>
 	///</summary>
-	public class CatNodesQueryString : FluentQueryString<CatNodesQueryString> 
+	public class CatNodesRequestParameters : FluentRequestParameters<CatNodesRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatNodesQueryString Local(bool local)
+		public CatNodesRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -523,7 +523,7 @@ public CatNodesQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatNodesQueryString MasterTimeout(string master_timeout)
+		public CatNodesRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -533,7 +533,7 @@ public CatNodesQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatNodesQueryString H(params string[] h)
+		public CatNodesRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -543,7 +543,7 @@ public CatNodesQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatNodesQueryString Help(bool help)
+		public CatNodesRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -553,7 +553,7 @@ public CatNodesQueryString Help(bool help)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatNodesQueryString V(bool v)
+		public CatNodesRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -568,12 +568,12 @@ public CatNodesQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-pending-tasks.html
 	///</pre>
 	///</summary>
-	public class CatPendingTasksQueryString : FluentQueryString<CatPendingTasksQueryString> 
+	public class CatPendingTasksRequestParameters : FluentRequestParameters<CatPendingTasksRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatPendingTasksQueryString Local(bool local)
+		public CatPendingTasksRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -583,7 +583,7 @@ public CatPendingTasksQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatPendingTasksQueryString MasterTimeout(string master_timeout)
+		public CatPendingTasksRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -593,7 +593,7 @@ public CatPendingTasksQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatPendingTasksQueryString H(params string[] h)
+		public CatPendingTasksRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -603,7 +603,7 @@ public CatPendingTasksQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatPendingTasksQueryString Help(bool help)
+		public CatPendingTasksRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -613,7 +613,7 @@ public CatPendingTasksQueryString Help(bool help)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatPendingTasksQueryString V(bool v)
+		public CatPendingTasksRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -628,12 +628,12 @@ public CatPendingTasksQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html
 	///</pre>
 	///</summary>
-	public class CatRecoveryQueryString : FluentQueryString<CatRecoveryQueryString> 
+	public class CatRecoveryRequestParameters : FluentRequestParameters<CatRecoveryRequestParameters> 
 	{
 		
 		internal BytesOptions _bytes { get; set; }
 		///<summary>The unit in which to display byte values</summary>
-		public CatRecoveryQueryString Bytes(BytesOptions bytes)
+		public CatRecoveryRequestParameters Bytes(BytesOptions bytes)
 		{
 			this._bytes = bytes;
 			this.Add("bytes", this._bytes);
@@ -643,7 +643,7 @@ public CatRecoveryQueryString Bytes(BytesOptions bytes)
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatRecoveryQueryString Local(bool local)
+		public CatRecoveryRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -653,7 +653,7 @@ public CatRecoveryQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatRecoveryQueryString MasterTimeout(string master_timeout)
+		public CatRecoveryRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -663,7 +663,7 @@ public CatRecoveryQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatRecoveryQueryString H(params string[] h)
+		public CatRecoveryRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -673,7 +673,7 @@ public CatRecoveryQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatRecoveryQueryString Help(bool help)
+		public CatRecoveryRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -683,7 +683,7 @@ public CatRecoveryQueryString Help(bool help)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatRecoveryQueryString V(bool v)
+		public CatRecoveryRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -698,12 +698,12 @@ public CatRecoveryQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html
 	///</pre>
 	///</summary>
-	public class CatShardsQueryString : FluentQueryString<CatShardsQueryString> 
+	public class CatShardsRequestParameters : FluentRequestParameters<CatShardsRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatShardsQueryString Local(bool local)
+		public CatShardsRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -713,7 +713,7 @@ public CatShardsQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatShardsQueryString MasterTimeout(string master_timeout)
+		public CatShardsRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -723,7 +723,7 @@ public CatShardsQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatShardsQueryString H(params string[] h)
+		public CatShardsRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -733,7 +733,7 @@ public CatShardsQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatShardsQueryString Help(bool help)
+		public CatShardsRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -743,7 +743,7 @@ public CatShardsQueryString Help(bool help)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatShardsQueryString V(bool v)
+		public CatShardsRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -758,12 +758,12 @@ public CatShardsQueryString V(bool v)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/master/cat-thread-pool.html
 	///</pre>
 	///</summary>
-	public class CatThreadPoolQueryString : FluentQueryString<CatThreadPoolQueryString> 
+	public class CatThreadPoolRequestParameters : FluentRequestParameters<CatThreadPoolRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public CatThreadPoolQueryString Local(bool local)
+		public CatThreadPoolRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -773,7 +773,7 @@ public CatThreadPoolQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public CatThreadPoolQueryString MasterTimeout(string master_timeout)
+		public CatThreadPoolRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -783,7 +783,7 @@ public CatThreadPoolQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _h { get; set; }
 		///<summary>Comma-separated list of column names to display</summary>
-		public CatThreadPoolQueryString H(params string[] h)
+		public CatThreadPoolRequestParameters H(params string[] h)
 		{
 			this._h = h;
 			this.Add("h", this._h);
@@ -793,7 +793,7 @@ public CatThreadPoolQueryString H(params string[] h)
 		
 		internal bool _help { get; set; }
 		///<summary>Return help information</summary>
-		public CatThreadPoolQueryString Help(bool help)
+		public CatThreadPoolRequestParameters Help(bool help)
 		{
 			this._help = help;
 			this.Add("help", this._help);
@@ -803,7 +803,7 @@ public CatThreadPoolQueryString Help(bool help)
 		
 		internal bool _v { get; set; }
 		///<summary>Verbose mode. Display column headers</summary>
-		public CatThreadPoolQueryString V(bool v)
+		public CatThreadPoolRequestParameters V(bool v)
 		{
 			this._v = v;
 			this.Add("v", this._v);
@@ -813,7 +813,7 @@ public CatThreadPoolQueryString V(bool v)
 		
 		internal bool _full_id { get; set; }
 		///<summary>Enables displaying the complete node ids</summary>
-		public CatThreadPoolQueryString FullId(bool full_id)
+		public CatThreadPoolRequestParameters FullId(bool full_id)
 		{
 			this._full_id = full_id;
 			this.Add("full_id", this._full_id);
@@ -828,7 +828,7 @@ public CatThreadPoolQueryString FullId(bool full_id)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
 	///</pre>
 	///</summary>
-	public class ClearScrollQueryString : FluentQueryString<ClearScrollQueryString> 
+	public class ClearScrollRequestParameters : FluentRequestParameters<ClearScrollRequestParameters> 
 	{
 	}
 	
@@ -838,12 +838,12 @@ public class ClearScrollQueryString : FluentQueryString<ClearScrollQueryString>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
 	///</pre>
 	///</summary>
-	public class ClusterGetSettingsQueryString : FluentQueryString<ClusterGetSettingsQueryString> 
+	public class ClusterGetSettingsRequestParameters : FluentRequestParameters<ClusterGetSettingsRequestParameters> 
 	{
 		
 		internal bool _flat_settings { get; set; }
 		///<summary>Return settings in flat format (default: false)</summary>
-		public ClusterGetSettingsQueryString FlatSettings(bool flat_settings)
+		public ClusterGetSettingsRequestParameters FlatSettings(bool flat_settings)
 		{
 			this._flat_settings = flat_settings;
 			this.Add("flat_settings", this._flat_settings);
@@ -853,7 +853,7 @@ public ClusterGetSettingsQueryString FlatSettings(bool flat_settings)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public ClusterGetSettingsQueryString MasterTimeout(string master_timeout)
+		public ClusterGetSettingsRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -863,7 +863,7 @@ public ClusterGetSettingsQueryString MasterTimeout(string master_timeout)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public ClusterGetSettingsQueryString Timeout(string timeout)
+		public ClusterGetSettingsRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -878,12 +878,12 @@ public ClusterGetSettingsQueryString Timeout(string timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html
 	///</pre>
 	///</summary>
-	public class ClusterHealthQueryString : FluentQueryString<ClusterHealthQueryString> 
+	public class ClusterHealthRequestParameters : FluentRequestParameters<ClusterHealthRequestParameters> 
 	{
 		
 		internal LevelOptions _level { get; set; }
 		///<summary>Specify the level of detail for returned information</summary>
-		public ClusterHealthQueryString Level(LevelOptions level)
+		public ClusterHealthRequestParameters Level(LevelOptions level)
 		{
 			this._level = level;
 			this.Add("level", this._level);
@@ -893,7 +893,7 @@ public ClusterHealthQueryString Level(LevelOptions level)
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public ClusterHealthQueryString Local(bool local)
+		public ClusterHealthRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -903,7 +903,7 @@ public ClusterHealthQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public ClusterHealthQueryString MasterTimeout(string master_timeout)
+		public ClusterHealthRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -913,7 +913,7 @@ public ClusterHealthQueryString MasterTimeout(string master_timeout)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public ClusterHealthQueryString Timeout(string timeout)
+		public ClusterHealthRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -923,7 +923,7 @@ public ClusterHealthQueryString Timeout(string timeout)
 		
 		internal int _wait_for_active_shards { get; set; }
 		///<summary>Wait until the specified number of shards is active</summary>
-		public ClusterHealthQueryString WaitForActiveShards(int wait_for_active_shards)
+		public ClusterHealthRequestParameters WaitForActiveShards(int wait_for_active_shards)
 		{
 			this._wait_for_active_shards = wait_for_active_shards;
 			this.Add("wait_for_active_shards", this._wait_for_active_shards);
@@ -933,7 +933,7 @@ public ClusterHealthQueryString WaitForActiveShards(int wait_for_active_shards)
 		
 		internal string _wait_for_nodes { get; set; }
 		///<summary>Wait until the specified number of nodes is available</summary>
-		public ClusterHealthQueryString WaitForNodes(string wait_for_nodes)
+		public ClusterHealthRequestParameters WaitForNodes(string wait_for_nodes)
 		{
 			this._wait_for_nodes = wait_for_nodes;
 			this.Add("wait_for_nodes", this._wait_for_nodes);
@@ -943,7 +943,7 @@ public ClusterHealthQueryString WaitForNodes(string wait_for_nodes)
 		
 		internal int _wait_for_relocating_shards { get; set; }
 		///<summary>Wait until the specified number of relocating shards is finished</summary>
-		public ClusterHealthQueryString WaitForRelocatingShards(int wait_for_relocating_shards)
+		public ClusterHealthRequestParameters WaitForRelocatingShards(int wait_for_relocating_shards)
 		{
 			this._wait_for_relocating_shards = wait_for_relocating_shards;
 			this.Add("wait_for_relocating_shards", this._wait_for_relocating_shards);
@@ -953,7 +953,7 @@ public ClusterHealthQueryString WaitForRelocatingShards(int wait_for_relocating_
 		
 		internal WaitForStatusOptions _wait_for_status { get; set; }
 		///<summary>Wait until cluster is in a specific state</summary>
-		public ClusterHealthQueryString WaitForStatus(WaitForStatusOptions wait_for_status)
+		public ClusterHealthRequestParameters WaitForStatus(WaitForStatusOptions wait_for_status)
 		{
 			this._wait_for_status = wait_for_status;
 			this.Add("wait_for_status", this._wait_for_status);
@@ -968,12 +968,12 @@ public ClusterHealthQueryString WaitForStatus(WaitForStatusOptions wait_for_stat
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-pending.html
 	///</pre>
 	///</summary>
-	public class ClusterPendingTasksQueryString : FluentQueryString<ClusterPendingTasksQueryString> 
+	public class ClusterPendingTasksRequestParameters : FluentRequestParameters<ClusterPendingTasksRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public ClusterPendingTasksQueryString Local(bool local)
+		public ClusterPendingTasksRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -983,7 +983,7 @@ public ClusterPendingTasksQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public ClusterPendingTasksQueryString MasterTimeout(string master_timeout)
+		public ClusterPendingTasksRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -998,12 +998,12 @@ public ClusterPendingTasksQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html
 	///</pre>
 	///</summary>
-	public class ClusterPutSettingsQueryString : FluentQueryString<ClusterPutSettingsQueryString> 
+	public class ClusterPutSettingsRequestParameters : FluentRequestParameters<ClusterPutSettingsRequestParameters> 
 	{
 		
 		internal bool _flat_settings { get; set; }
 		///<summary>Return settings in flat format (default: false)</summary>
-		public ClusterPutSettingsQueryString FlatSettings(bool flat_settings)
+		public ClusterPutSettingsRequestParameters FlatSettings(bool flat_settings)
 		{
 			this._flat_settings = flat_settings;
 			this.Add("flat_settings", this._flat_settings);
@@ -1018,12 +1018,12 @@ public ClusterPutSettingsQueryString FlatSettings(bool flat_settings)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html
 	///</pre>
 	///</summary>
-	public class ClusterRerouteQueryString : FluentQueryString<ClusterRerouteQueryString> 
+	public class ClusterRerouteRequestParameters : FluentRequestParameters<ClusterRerouteRequestParameters> 
 	{
 		
 		internal bool _dry_run { get; set; }
 		///<summary>Simulate the operation only and return the resulting state</summary>
-		public ClusterRerouteQueryString DryRun(bool dry_run)
+		public ClusterRerouteRequestParameters DryRun(bool dry_run)
 		{
 			this._dry_run = dry_run;
 			this.Add("dry_run", this._dry_run);
@@ -1033,7 +1033,7 @@ public ClusterRerouteQueryString DryRun(bool dry_run)
 		
 		internal bool _filter_metadata { get; set; }
 		///<summary>Don&#39;t return cluster state metadata (default: false)</summary>
-		public ClusterRerouteQueryString FilterMetadata(bool filter_metadata)
+		public ClusterRerouteRequestParameters FilterMetadata(bool filter_metadata)
 		{
 			this._filter_metadata = filter_metadata;
 			this.Add("filter_metadata", this._filter_metadata);
@@ -1043,7 +1043,7 @@ public ClusterRerouteQueryString FilterMetadata(bool filter_metadata)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public ClusterRerouteQueryString MasterTimeout(string master_timeout)
+		public ClusterRerouteRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -1053,7 +1053,7 @@ public ClusterRerouteQueryString MasterTimeout(string master_timeout)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public ClusterRerouteQueryString Timeout(string timeout)
+		public ClusterRerouteRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -1068,12 +1068,12 @@ public ClusterRerouteQueryString Timeout(string timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html
 	///</pre>
 	///</summary>
-	public class ClusterStateQueryString : FluentQueryString<ClusterStateQueryString> 
+	public class ClusterStateRequestParameters : FluentRequestParameters<ClusterStateRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public ClusterStateQueryString Local(bool local)
+		public ClusterStateRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -1083,7 +1083,7 @@ public ClusterStateQueryString Local(bool local)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public ClusterStateQueryString MasterTimeout(string master_timeout)
+		public ClusterStateRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -1093,7 +1093,7 @@ public ClusterStateQueryString MasterTimeout(string master_timeout)
 		
 		internal  string[] _index_templates { get; set; }
 		///<summary>A comma separated list to return specific index templates when returning metadata</summary>
-		public ClusterStateQueryString IndexTemplates(params string[] index_templates)
+		public ClusterStateRequestParameters IndexTemplates(params string[] index_templates)
 		{
 			this._index_templates = index_templates;
 			this.Add("index_templates", this._index_templates);
@@ -1103,7 +1103,7 @@ public ClusterStateQueryString IndexTemplates(params string[] index_templates)
 		
 		internal bool _flat_settings { get; set; }
 		///<summary>Return settings in flat format (default: false)</summary>
-		public ClusterStateQueryString FlatSettings(bool flat_settings)
+		public ClusterStateRequestParameters FlatSettings(bool flat_settings)
 		{
 			this._flat_settings = flat_settings;
 			this.Add("flat_settings", this._flat_settings);
@@ -1118,12 +1118,12 @@ public ClusterStateQueryString FlatSettings(bool flat_settings)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html
 	///</pre>
 	///</summary>
-	public class ClusterStatsQueryString : FluentQueryString<ClusterStatsQueryString> 
+	public class ClusterStatsRequestParameters : FluentRequestParameters<ClusterStatsRequestParameters> 
 	{
 		
 		internal bool _flat_settings { get; set; }
 		///<summary>Return settings in flat format (default: false)</summary>
-		public ClusterStatsQueryString FlatSettings(bool flat_settings)
+		public ClusterStatsRequestParameters FlatSettings(bool flat_settings)
 		{
 			this._flat_settings = flat_settings;
 			this.Add("flat_settings", this._flat_settings);
@@ -1133,7 +1133,7 @@ public ClusterStatsQueryString FlatSettings(bool flat_settings)
 		
 		internal bool _human { get; set; }
 		///<summary>Whether to return time and byte values in human-readable format.</summary>
-		public ClusterStatsQueryString Human(bool human)
+		public ClusterStatsRequestParameters Human(bool human)
 		{
 			this._human = human;
 			this.Add("human", this._human);
@@ -1148,12 +1148,12 @@ public ClusterStatsQueryString Human(bool human)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html
 	///</pre>
 	///</summary>
-	public class CountQueryString : FluentQueryString<CountQueryString> 
+	public class CountRequestParameters : FluentRequestParameters<CountRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public CountQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public CountRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -1163,7 +1163,7 @@ public CountQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 CountQueryString AllowNoIndices(bool allow_no_indices)
+		public CountRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -1173,7 +1173,7 @@ public CountQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public CountQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public CountRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -1183,7 +1183,7 @@ public CountQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		
 		internal int _min_score { get; set; }
 		///<summary>Include only documents with a specific `_score` value in the result</summary>
-		public CountQueryString MinScore(int min_score)
+		public CountRequestParameters MinScore(int min_score)
 		{
 			this._min_score = min_score;
 			this.Add("min_score", this._min_score);
@@ -1193,7 +1193,7 @@ public CountQueryString MinScore(int min_score)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public CountQueryString Preference(string preference)
+		public CountRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -1203,7 +1203,7 @@ public CountQueryString Preference(string preference)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public CountQueryString Routing(string routing)
+		public CountRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -1213,7 +1213,7 @@ public CountQueryString Routing(string routing)
 		
 		internal string _source { get; set; }
 		///<summary>The URL-encoded query definition (instead of using the request body)</summary>
-		public CountQueryString Source(string source)
+		public CountRequestParameters Source(string source)
 		{
 			this._source = source;
 			this.Add("source", this._source);
@@ -1228,12 +1228,12 @@ public CountQueryString Source(string source)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
 	///</pre>
 	///</summary>
-	public class CountPercolateQueryString : FluentQueryString<CountPercolateQueryString> 
+	public class CountPercolateRequestParameters : FluentRequestParameters<CountPercolateRequestParameters> 
 	{
 		
 		internal  string[] _routing { get; set; }
 		///<summary>A comma-separated list of specific routing values</summary>
-		public CountPercolateQueryString Routing(params string[] routing)
+		public CountPercolateRequestParameters Routing(params string[] routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -1243,7 +1243,7 @@ public CountPercolateQueryString Routing(params string[] routing)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public CountPercolateQueryString Preference(string preference)
+		public CountPercolateRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -1253,7 +1253,7 @@ public CountPercolateQueryString Preference(string preference)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public CountPercolateQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public CountPercolateRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -1263,7 +1263,7 @@ public CountPercolateQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 CountPercolateQueryString AllowNoIndices(bool allow_no_indices)
+		public CountPercolateRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -1273,7 +1273,7 @@ public CountPercolateQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public CountPercolateQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public CountPercolateRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -1283,7 +1283,7 @@ public CountPercolateQueryString ExpandWildcards(ExpandWildcardsOptions expand_w
 		
 		internal string _percolate_index { get; set; }
 		///<summary>The index to count percolate the document into. Defaults to index.</summary>
-		public CountPercolateQueryString PercolateIndex(string percolate_index)
+		public CountPercolateRequestParameters PercolateIndex(string percolate_index)
 		{
 			this._percolate_index = percolate_index;
 			this.Add("percolate_index", this._percolate_index);
@@ -1293,7 +1293,7 @@ public CountPercolateQueryString PercolateIndex(string percolate_index)
 		
 		internal string _percolate_type { get; set; }
 		///<summary>The type to count percolate document into. Defaults to type.</summary>
-		public CountPercolateQueryString PercolateType(string percolate_type)
+		public CountPercolateRequestParameters PercolateType(string percolate_type)
 		{
 			this._percolate_type = percolate_type;
 			this.Add("percolate_type", this._percolate_type);
@@ -1303,7 +1303,7 @@ public CountPercolateQueryString PercolateType(string percolate_type)
 		
 		internal int _version { get; set; }
 		///<summary>Explicit version number for concurrency control</summary>
-		public CountPercolateQueryString Version(int version)
+		public CountPercolateRequestParameters Version(int version)
 		{
 			this._version = version;
 			this.Add("version", this._version);
@@ -1313,7 +1313,7 @@ public CountPercolateQueryString Version(int version)
 		
 		internal VersionTypeOptions _version_type { get; set; }
 		///<summary>Specific version type</summary>
-		public CountPercolateQueryString VersionType(VersionTypeOptions version_type)
+		public CountPercolateRequestParameters VersionType(VersionTypeOptions version_type)
 		{
 			this._version_type = version_type;
 			this.Add("version_type", this._version_type);
@@ -1328,12 +1328,12 @@ public CountPercolateQueryString VersionType(VersionTypeOptions version_type)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete.html
 	///</pre>
 	///</summary>
-	public class DeleteQueryString : FluentQueryString<DeleteQueryString> 
+	public class DeleteRequestParameters : FluentRequestParameters<DeleteRequestParameters> 
 	{
 		
 		internal ConsistencyOptions _consistency { get; set; }
 		///<summary>Specific write consistency setting for the operation</summary>
-		public DeleteQueryString Consistency(ConsistencyOptions consistency)
+		public DeleteRequestParameters Consistency(ConsistencyOptions consistency)
 		{
 			this._consistency = consistency;
 			this.Add("consistency", this._consistency);
@@ -1343,7 +1343,7 @@ public DeleteQueryString Consistency(ConsistencyOptions consistency)
 		
 		internal string _parent { get; set; }
 		///<summary>ID of parent document</summary>
-		public DeleteQueryString Parent(string parent)
+		public DeleteRequestParameters Parent(string parent)
 		{
 			this._parent = parent;
 			this.Add("parent", this._parent);
@@ -1353,7 +1353,7 @@ public DeleteQueryString Parent(string parent)
 		
 		internal bool _refresh { get; set; }
 		///<summary>Refresh the index after performing the operation</summary>
-		public DeleteQueryString Refresh(bool refresh)
+		public DeleteRequestParameters Refresh(bool refresh)
 		{
 			this._refresh = refresh;
 			this.Add("refresh", this._refresh);
@@ -1363,7 +1363,7 @@ public DeleteQueryString Refresh(bool refresh)
 		
 		internal ReplicationOptions _replication { get; set; }
 		///<summary>Specific replication type</summary>
-		public DeleteQueryString Replication(ReplicationOptions replication)
+		public DeleteRequestParameters Replication(ReplicationOptions replication)
 		{
 			this._replication = replication;
 			this.Add("replication", this._replication);
@@ -1373,7 +1373,7 @@ public DeleteQueryString Replication(ReplicationOptions replication)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public DeleteQueryString Routing(string routing)
+		public DeleteRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -1383,7 +1383,7 @@ public DeleteQueryString Routing(string routing)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public DeleteQueryString Timeout(string timeout)
+		public DeleteRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -1393,7 +1393,7 @@ public DeleteQueryString Timeout(string timeout)
 		
 		internal int _version { get; set; }
 		///<summary>Explicit version number for concurrency control</summary>
-		public DeleteQueryString Version(int version)
+		public DeleteRequestParameters Version(int version)
 		{
 			this._version = version;
 			this.Add("version", this._version);
@@ -1403,7 +1403,7 @@ public DeleteQueryString Version(int version)
 		
 		internal VersionTypeOptions _version_type { get; set; }
 		///<summary>Specific version type</summary>
-		public DeleteQueryString VersionType(VersionTypeOptions version_type)
+		public DeleteRequestParameters VersionType(VersionTypeOptions version_type)
 		{
 			this._version_type = version_type;
 			this.Add("version_type", this._version_type);
@@ -1418,12 +1418,12 @@ public DeleteQueryString VersionType(VersionTypeOptions version_type)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-delete-by-query.html
 	///</pre>
 	///</summary>
-	public class DeleteByQueryQueryString : FluentQueryString<DeleteByQueryQueryString> 
+	public class DeleteByQueryRequestParameters : FluentRequestParameters<DeleteByQueryRequestParameters> 
 	{
 		
 		internal string _analyzer { get; set; }
 		///<summary>The analyzer to use for the query string</summary>
-		public DeleteByQueryQueryString Analyzer(string analyzer)
+		public DeleteByQueryRequestParameters Analyzer(string analyzer)
 		{
 			this._analyzer = analyzer;
 			this.Add("analyzer", this._analyzer);
@@ -1433,7 +1433,7 @@ public DeleteByQueryQueryString Analyzer(string analyzer)
 		
 		internal ConsistencyOptions _consistency { get; set; }
 		///<summary>Specific write consistency setting for the operation</summary>
-		public DeleteByQueryQueryString Consistency(ConsistencyOptions consistency)
+		public DeleteByQueryRequestParameters Consistency(ConsistencyOptions consistency)
 		{
 			this._consistency = consistency;
 			this.Add("consistency", this._consistency);
@@ -1443,7 +1443,7 @@ public DeleteByQueryQueryString Consistency(ConsistencyOptions consistency)
 		
 		internal DefaultOperatorOptions _default_operator { get; set; }
 		///<summary>The default operator for query string query (AND or OR)</summary>
-		public DeleteByQueryQueryString DefaultOperator(DefaultOperatorOptions default_operator)
+		public DeleteByQueryRequestParameters DefaultOperator(DefaultOperatorOptions default_operator)
 		{
 			this._default_operator = default_operator;
 			this.Add("default_operator", this._default_operator);
@@ -1453,7 +1453,7 @@ public DeleteByQueryQueryString DefaultOperator(DefaultOperatorOptions default_o
 		
 		internal string _df { get; set; }
 		///<summary>The field to use as default where no field prefix is given in the query string</summary>
-		public DeleteByQueryQueryString Df(string df)
+		public DeleteByQueryRequestParameters Df(string df)
 		{
 			this._df = df;
 			this.Add("df", this._df);
@@ -1463,7 +1463,7 @@ public DeleteByQueryQueryString Df(string df)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public DeleteByQueryQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public DeleteByQueryRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -1473,7 +1473,7 @@ public DeleteByQueryQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 DeleteByQueryQueryString AllowNoIndices(bool allow_no_indices)
+		public DeleteByQueryRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -1483,7 +1483,7 @@ public DeleteByQueryQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public DeleteByQueryQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public DeleteByQueryRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -1493,7 +1493,7 @@ public DeleteByQueryQueryString ExpandWildcards(ExpandWildcardsOptions expand_wi
 		
 		internal ReplicationOptions _replication { get; set; }
 		///<summary>Specific replication type</summary>
-		public DeleteByQueryQueryString Replication(ReplicationOptions replication)
+		public DeleteByQueryRequestParameters Replication(ReplicationOptions replication)
 		{
 			this._replication = replication;
 			this.Add("replication", this._replication);
@@ -1503,7 +1503,7 @@ public DeleteByQueryQueryString Replication(ReplicationOptions replication)
 		
 		internal string _q { get; set; }
 		///<summary>Query in the Lucene query string syntax</summary>
-		public DeleteByQueryQueryString Q(string q)
+		public DeleteByQueryRequestParameters Q(string q)
 		{
 			this._q = q;
 			this.Add("q", this._q);
@@ -1513,7 +1513,7 @@ public DeleteByQueryQueryString Q(string q)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public DeleteByQueryQueryString Routing(string routing)
+		public DeleteByQueryRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -1523,7 +1523,7 @@ public DeleteByQueryQueryString Routing(string routing)
 		
 		internal string _source { get; set; }
 		///<summary>The URL-encoded query definition (instead of using the request body)</summary>
-		public DeleteByQueryQueryString Source(string source)
+		public DeleteByQueryRequestParameters Source(string source)
 		{
 			this._source = source;
 			this.Add("source", this._source);
@@ -1533,7 +1533,7 @@ public DeleteByQueryQueryString Source(string source)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public DeleteByQueryQueryString Timeout(string timeout)
+		public DeleteByQueryRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -1548,12 +1548,12 @@ public DeleteByQueryQueryString Timeout(string timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
 	///</pre>
 	///</summary>
-	public class ExistsQueryString : FluentQueryString<ExistsQueryString> 
+	public class ExistsRequestParameters : FluentRequestParameters<ExistsRequestParameters> 
 	{
 		
 		internal string _parent { get; set; }
 		///<summary>The ID of the parent document</summary>
-		public ExistsQueryString Parent(string parent)
+		public ExistsRequestParameters Parent(string parent)
 		{
 			this._parent = parent;
 			this.Add("parent", this._parent);
@@ -1563,7 +1563,7 @@ public ExistsQueryString Parent(string parent)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public ExistsQueryString Preference(string preference)
+		public ExistsRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -1573,7 +1573,7 @@ public ExistsQueryString Preference(string preference)
 		
 		internal bool _realtime { get; set; }
 		///<summary>Specify whether to perform the operation in realtime or search mode</summary>
-		public ExistsQueryString Realtime(bool realtime)
+		public ExistsRequestParameters Realtime(bool realtime)
 		{
 			this._realtime = realtime;
 			this.Add("realtime", this._realtime);
@@ -1583,7 +1583,7 @@ public ExistsQueryString Realtime(bool realtime)
 		
 		internal bool _refresh { get; set; }
 		///<summary>Refresh the shard containing the document before performing the operation</summary>
-		public ExistsQueryString Refresh(bool refresh)
+		public ExistsRequestParameters Refresh(bool refresh)
 		{
 			this._refresh = refresh;
 			this.Add("refresh", this._refresh);
@@ -1593,7 +1593,7 @@ public ExistsQueryString Refresh(bool refresh)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public ExistsQueryString Routing(string routing)
+		public ExistsRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -1608,12 +1608,12 @@ public ExistsQueryString Routing(string routing)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-explain.html
 	///</pre>
 	///</summary>
-	public class ExplainQueryString : FluentQueryString<ExplainQueryString> 
+	public class ExplainRequestParameters : FluentRequestParameters<ExplainRequestParameters> 
 	{
 		
 		internal bool _analyze_wildcard { get; set; }
 		///<summary>Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)</summary>
-		public ExplainQueryString AnalyzeWildcard(bool analyze_wildcard)
+		public ExplainRequestParameters AnalyzeWildcard(bool analyze_wildcard)
 		{
 			this._analyze_wildcard = analyze_wildcard;
 			this.Add("analyze_wildcard", this._analyze_wildcard);
@@ -1623,7 +1623,7 @@ public ExplainQueryString AnalyzeWildcard(bool analyze_wildcard)
 		
 		internal string _analyzer { get; set; }
 		///<summary>The analyzer for the query string query</summary>
-		public ExplainQueryString Analyzer(string analyzer)
+		public ExplainRequestParameters Analyzer(string analyzer)
 		{
 			this._analyzer = analyzer;
 			this.Add("analyzer", this._analyzer);
@@ -1633,7 +1633,7 @@ public ExplainQueryString Analyzer(string analyzer)
 		
 		internal DefaultOperatorOptions _default_operator { get; set; }
 		///<summary>The default operator for query string query (AND or OR)</summary>
-		public ExplainQueryString DefaultOperator(DefaultOperatorOptions default_operator)
+		public ExplainRequestParameters DefaultOperator(DefaultOperatorOptions default_operator)
 		{
 			this._default_operator = default_operator;
 			this.Add("default_operator", this._default_operator);
@@ -1643,7 +1643,7 @@ public ExplainQueryString DefaultOperator(DefaultOperatorOptions default_operato
 		
 		internal string _df { get; set; }
 		///<summary>The default field for query string query (default: _all)</summary>
-		public ExplainQueryString Df(string df)
+		public ExplainRequestParameters Df(string df)
 		{
 			this._df = df;
 			this.Add("df", this._df);
@@ -1653,7 +1653,7 @@ public ExplainQueryString Df(string df)
 		
 		internal IEnumerable<object> _fields { get; set; }
 		///<summary>A comma-separated list of fields to return in the response</summary>
-		public ExplainQueryString Fields(params string[] fields)
+		public ExplainRequestParameters Fields(params string[] fields)
 		{
 			this._fields = fields.Select(f=>(object)f);
 			this.Add("fields", this._fields);
@@ -1663,7 +1663,7 @@ public ExplainQueryString Fields(params string[] fields)
 		
 		internal bool _lenient { get; set; }
 		///<summary>Specify whether format-based query failures (such as providing text to a numeric field) should be ignored</summary>
-		public ExplainQueryString Lenient(bool lenient)
+		public ExplainRequestParameters Lenient(bool lenient)
 		{
 			this._lenient = lenient;
 			this.Add("lenient", this._lenient);
@@ -1673,7 +1673,7 @@ public ExplainQueryString Lenient(bool lenient)
 		
 		internal bool _lowercase_expanded_terms { get; set; }
 		///<summary>Specify whether query terms should be lowercased</summary>
-		public ExplainQueryString LowercaseExpandedTerms(bool lowercase_expanded_terms)
+		public ExplainRequestParameters LowercaseExpandedTerms(bool lowercase_expanded_terms)
 		{
 			this._lowercase_expanded_terms = lowercase_expanded_terms;
 			this.Add("lowercase_expanded_terms", this._lowercase_expanded_terms);
@@ -1683,7 +1683,7 @@ public ExplainQueryString LowercaseExpandedTerms(bool lowercase_expanded_terms)
 		
 		internal string _parent { get; set; }
 		///<summary>The ID of the parent document</summary>
-		public ExplainQueryString Parent(string parent)
+		public ExplainRequestParameters Parent(string parent)
 		{
 			this._parent = parent;
 			this.Add("parent", this._parent);
@@ -1693,7 +1693,7 @@ public ExplainQueryString Parent(string parent)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public ExplainQueryString Preference(string preference)
+		public ExplainRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -1703,7 +1703,7 @@ public ExplainQueryString Preference(string preference)
 		
 		internal string _q { get; set; }
 		///<summary>Query in the Lucene query string syntax</summary>
-		public ExplainQueryString Q(string q)
+		public ExplainRequestParameters Q(string q)
 		{
 			this._q = q;
 			this.Add("q", this._q);
@@ -1713,7 +1713,7 @@ public ExplainQueryString Q(string q)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public ExplainQueryString Routing(string routing)
+		public ExplainRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -1723,7 +1723,7 @@ public ExplainQueryString Routing(string routing)
 		
 		internal string _source { get; set; }
 		///<summary>The URL-encoded query definition (instead of using the request body)</summary>
-		public ExplainQueryString Source(string source)
+		public ExplainRequestParameters Source(string source)
 		{
 			this._source = source;
 			this.Add("source", this._source);
@@ -1733,7 +1733,7 @@ public ExplainQueryString Source(string source)
 		
 		internal  string[] __source { get; set; }
 		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
-		public ExplainQueryString Source(params string[] _source)
+		public ExplainRequestParameters Source(params string[] _source)
 		{
 			this.__source = _source;
 			this.Add("_source", this.__source);
@@ -1743,7 +1743,7 @@ public ExplainQueryString Source(params string[] _source)
 		
 		internal IEnumerable<object> __source_exclude { get; set; }
 		///<summary>A list of fields to exclude from the returned _source field</summary>
-		public ExplainQueryString SourceExclude(params string[] _source_exclude)
+		public ExplainRequestParameters SourceExclude(params string[] _source_exclude)
 		{
 			this.__source_exclude = _source_exclude.Select(f=>(object)f);
 			this.Add("_source_exclude", this.__source_exclude);
@@ -1753,7 +1753,7 @@ public ExplainQueryString SourceExclude(params string[] _source_exclude)
 		
 		internal IEnumerable<object> __source_include { get; set; }
 		///<summary>A list of fields to extract and return from the _source field</summary>
-		public ExplainQueryString SourceInclude(params string[] _source_include)
+		public ExplainRequestParameters SourceInclude(params string[] _source_include)
 		{
 			this.__source_include = _source_include.Select(f=>(object)f);
 			this.Add("_source_include", this.__source_include);
@@ -1768,12 +1768,12 @@ public ExplainQueryString SourceInclude(params string[] _source_include)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
 	///</pre>
 	///</summary>
-	public class GetQueryString : FluentQueryString<GetQueryString> 
+	public class GetRequestParameters : FluentRequestParameters<GetRequestParameters> 
 	{
 		
 		internal IEnumerable<object> _fields { get; set; }
 		///<summary>A comma-separated list of fields to return in the response</summary>
-		public GetQueryString Fields(params string[] fields)
+		public GetRequestParameters Fields(params string[] fields)
 		{
 			this._fields = fields.Select(f=>(object)f);
 			this.Add("fields", this._fields);
@@ -1783,7 +1783,7 @@ public GetQueryString Fields(params string[] fields)
 		
 		internal string _parent { get; set; }
 		///<summary>The ID of the parent document</summary>
-		public GetQueryString Parent(string parent)
+		public GetRequestParameters Parent(string parent)
 		{
 			this._parent = parent;
 			this.Add("parent", this._parent);
@@ -1793,7 +1793,7 @@ public GetQueryString Parent(string parent)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public GetQueryString Preference(string preference)
+		public GetRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -1803,7 +1803,7 @@ public GetQueryString Preference(string preference)
 		
 		internal bool _realtime { get; set; }
 		///<summary>Specify whether to perform the operation in realtime or search mode</summary>
-		public GetQueryString Realtime(bool realtime)
+		public GetRequestParameters Realtime(bool realtime)
 		{
 			this._realtime = realtime;
 			this.Add("realtime", this._realtime);
@@ -1813,7 +1813,7 @@ public GetQueryString Realtime(bool realtime)
 		
 		internal bool _refresh { get; set; }
 		///<summary>Refresh the shard containing the document before performing the operation</summary>
-		public GetQueryString Refresh(bool refresh)
+		public GetRequestParameters Refresh(bool refresh)
 		{
 			this._refresh = refresh;
 			this.Add("refresh", this._refresh);
@@ -1823,7 +1823,7 @@ public GetQueryString Refresh(bool refresh)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public GetQueryString Routing(string routing)
+		public GetRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -1833,7 +1833,7 @@ public GetQueryString Routing(string routing)
 		
 		internal  string[] __source { get; set; }
 		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
-		public GetQueryString Source(params string[] _source)
+		public GetRequestParameters Source(params string[] _source)
 		{
 			this.__source = _source;
 			this.Add("_source", this.__source);
@@ -1843,7 +1843,7 @@ public GetQueryString Source(params string[] _source)
 		
 		internal IEnumerable<object> __source_exclude { get; set; }
 		///<summary>A list of fields to exclude from the returned _source field</summary>
-		public GetQueryString SourceExclude(params string[] _source_exclude)
+		public GetRequestParameters SourceExclude(params string[] _source_exclude)
 		{
 			this.__source_exclude = _source_exclude.Select(f=>(object)f);
 			this.Add("_source_exclude", this.__source_exclude);
@@ -1853,7 +1853,7 @@ public GetQueryString SourceExclude(params string[] _source_exclude)
 		
 		internal IEnumerable<object> __source_include { get; set; }
 		///<summary>A list of fields to extract and return from the _source field</summary>
-		public GetQueryString SourceInclude(params string[] _source_include)
+		public GetRequestParameters SourceInclude(params string[] _source_include)
 		{
 			this.__source_include = _source_include.Select(f=>(object)f);
 			this.Add("_source_include", this.__source_include);
@@ -1863,7 +1863,7 @@ public GetQueryString SourceInclude(params string[] _source_include)
 		
 		internal int _version { get; set; }
 		///<summary>Explicit version number for concurrency control</summary>
-		public GetQueryString Version(int version)
+		public GetRequestParameters Version(int version)
 		{
 			this._version = version;
 			this.Add("version", this._version);
@@ -1873,7 +1873,7 @@ public GetQueryString Version(int version)
 		
 		internal VersionTypeOptions _version_type { get; set; }
 		///<summary>Specific version type</summary>
-		public GetQueryString VersionType(VersionTypeOptions version_type)
+		public GetRequestParameters VersionType(VersionTypeOptions version_type)
 		{
 			this._version_type = version_type;
 			this.Add("version_type", this._version_type);
@@ -1888,12 +1888,12 @@ public GetQueryString VersionType(VersionTypeOptions version_type)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-get.html
 	///</pre>
 	///</summary>
-	public class SourceQueryString : FluentQueryString<SourceQueryString> 
+	public class SourceRequestParameters : FluentRequestParameters<SourceRequestParameters> 
 	{
 		
 		internal string _parent { get; set; }
 		///<summary>The ID of the parent document</summary>
-		public SourceQueryString Parent(string parent)
+		public SourceRequestParameters Parent(string parent)
 		{
 			this._parent = parent;
 			this.Add("parent", this._parent);
@@ -1903,7 +1903,7 @@ public SourceQueryString Parent(string parent)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public SourceQueryString Preference(string preference)
+		public SourceRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -1913,7 +1913,7 @@ public SourceQueryString Preference(string preference)
 		
 		internal bool _realtime { get; set; }
 		///<summary>Specify whether to perform the operation in realtime or search mode</summary>
-		public SourceQueryString Realtime(bool realtime)
+		public SourceRequestParameters Realtime(bool realtime)
 		{
 			this._realtime = realtime;
 			this.Add("realtime", this._realtime);
@@ -1923,7 +1923,7 @@ public SourceQueryString Realtime(bool realtime)
 		
 		internal bool _refresh { get; set; }
 		///<summary>Refresh the shard containing the document before performing the operation</summary>
-		public SourceQueryString Refresh(bool refresh)
+		public SourceRequestParameters Refresh(bool refresh)
 		{
 			this._refresh = refresh;
 			this.Add("refresh", this._refresh);
@@ -1933,7 +1933,7 @@ public SourceQueryString Refresh(bool refresh)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public SourceQueryString Routing(string routing)
+		public SourceRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -1943,7 +1943,7 @@ public SourceQueryString Routing(string routing)
 		
 		internal  string[] __source { get; set; }
 		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
-		public SourceQueryString Source(params string[] _source)
+		public SourceRequestParameters Source(params string[] _source)
 		{
 			this.__source = _source;
 			this.Add("_source", this.__source);
@@ -1953,7 +1953,7 @@ public SourceQueryString Source(params string[] _source)
 		
 		internal IEnumerable<object> __source_exclude { get; set; }
 		///<summary>A list of fields to exclude from the returned _source field</summary>
-		public SourceQueryString SourceExclude(params string[] _source_exclude)
+		public SourceRequestParameters SourceExclude(params string[] _source_exclude)
 		{
 			this.__source_exclude = _source_exclude.Select(f=>(object)f);
 			this.Add("_source_exclude", this.__source_exclude);
@@ -1963,7 +1963,7 @@ public SourceQueryString SourceExclude(params string[] _source_exclude)
 		
 		internal IEnumerable<object> __source_include { get; set; }
 		///<summary>A list of fields to extract and return from the _source field</summary>
-		public SourceQueryString SourceInclude(params string[] _source_include)
+		public SourceRequestParameters SourceInclude(params string[] _source_include)
 		{
 			this.__source_include = _source_include.Select(f=>(object)f);
 			this.Add("_source_include", this.__source_include);
@@ -1973,7 +1973,7 @@ public SourceQueryString SourceInclude(params string[] _source_include)
 		
 		internal int _version { get; set; }
 		///<summary>Explicit version number for concurrency control</summary>
-		public SourceQueryString Version(int version)
+		public SourceRequestParameters Version(int version)
 		{
 			this._version = version;
 			this.Add("version", this._version);
@@ -1983,7 +1983,7 @@ public SourceQueryString Version(int version)
 		
 		internal VersionTypeOptions _version_type { get; set; }
 		///<summary>Specific version type</summary>
-		public SourceQueryString VersionType(VersionTypeOptions version_type)
+		public SourceRequestParameters VersionType(VersionTypeOptions version_type)
 		{
 			this._version_type = version_type;
 			this.Add("version_type", this._version_type);
@@ -1998,12 +1998,12 @@ public SourceQueryString VersionType(VersionTypeOptions version_type)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-index_.html
 	///</pre>
 	///</summary>
-	public class IndexQueryString : FluentQueryString<IndexQueryString> 
+	public class IndexRequestParameters : FluentRequestParameters<IndexRequestParameters> 
 	{
 		
 		internal ConsistencyOptions _consistency { get; set; }
 		///<summary>Explicit write consistency setting for the operation</summary>
-		public IndexQueryString Consistency(ConsistencyOptions consistency)
+		public IndexRequestParameters Consistency(ConsistencyOptions consistency)
 		{
 			this._consistency = consistency;
 			this.Add("consistency", this._consistency);
@@ -2013,7 +2013,7 @@ public IndexQueryString Consistency(ConsistencyOptions consistency)
 		
 		internal OpTypeOptions _op_type { get; set; }
 		///<summary>Explicit operation type</summary>
-		public IndexQueryString OpType(OpTypeOptions op_type)
+		public IndexRequestParameters OpType(OpTypeOptions op_type)
 		{
 			this._op_type = op_type;
 			this.Add("op_type", this._op_type);
@@ -2023,7 +2023,7 @@ public IndexQueryString OpType(OpTypeOptions op_type)
 		
 		internal string _parent { get; set; }
 		///<summary>ID of the parent document</summary>
-		public IndexQueryString Parent(string parent)
+		public IndexRequestParameters Parent(string parent)
 		{
 			this._parent = parent;
 			this.Add("parent", this._parent);
@@ -2033,7 +2033,7 @@ public IndexQueryString Parent(string parent)
 		
 		internal bool _refresh { get; set; }
 		///<summary>Refresh the index after performing the operation</summary>
-		public IndexQueryString Refresh(bool refresh)
+		public IndexRequestParameters Refresh(bool refresh)
 		{
 			this._refresh = refresh;
 			this.Add("refresh", this._refresh);
@@ -2043,7 +2043,7 @@ public IndexQueryString Refresh(bool refresh)
 		
 		internal ReplicationOptions _replication { get; set; }
 		///<summary>Specific replication type</summary>
-		public IndexQueryString Replication(ReplicationOptions replication)
+		public IndexRequestParameters Replication(ReplicationOptions replication)
 		{
 			this._replication = replication;
 			this.Add("replication", this._replication);
@@ -2053,7 +2053,7 @@ public IndexQueryString Replication(ReplicationOptions replication)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public IndexQueryString Routing(string routing)
+		public IndexRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -2063,7 +2063,7 @@ public IndexQueryString Routing(string routing)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public IndexQueryString Timeout(string timeout)
+		public IndexRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -2073,7 +2073,7 @@ public IndexQueryString Timeout(string timeout)
 		
 		internal string _timestamp { get; set; }
 		///<summary>Explicit timestamp for the document</summary>
-		public IndexQueryString Timestamp(string timestamp)
+		public IndexRequestParameters Timestamp(string timestamp)
 		{
 			this._timestamp = timestamp;
 			this.Add("timestamp", this._timestamp);
@@ -2083,7 +2083,7 @@ public IndexQueryString Timestamp(string timestamp)
 		
 		internal string _ttl { get; set; }
 		///<summary>Expiration time for the document</summary>
-		public IndexQueryString Ttl(string ttl)
+		public IndexRequestParameters Ttl(string ttl)
 		{
 			this._ttl = ttl;
 			this.Add("ttl", this._ttl);
@@ -2093,7 +2093,7 @@ public IndexQueryString Ttl(string ttl)
 		
 		internal int _version { get; set; }
 		///<summary>Explicit version number for concurrency control</summary>
-		public IndexQueryString Version(int version)
+		public IndexRequestParameters Version(int version)
 		{
 			this._version = version;
 			this.Add("version", this._version);
@@ -2103,7 +2103,7 @@ public IndexQueryString Version(int version)
 		
 		internal VersionTypeOptions _version_type { get; set; }
 		///<summary>Specific version type</summary>
-		public IndexQueryString VersionType(VersionTypeOptions version_type)
+		public IndexRequestParameters VersionType(VersionTypeOptions version_type)
 		{
 			this._version_type = version_type;
 			this.Add("version_type", this._version_type);
@@ -2118,12 +2118,12 @@ public IndexQueryString VersionType(VersionTypeOptions version_type)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html
 	///</pre>
 	///</summary>
-	public class AnalyzeQueryString : FluentQueryString<AnalyzeQueryString> 
+	public class AnalyzeRequestParameters : FluentRequestParameters<AnalyzeRequestParameters> 
 	{
 		
 		internal string _analyzer { get; set; }
 		///<summary>The name of the analyzer to use</summary>
-		public AnalyzeQueryString Analyzer(string analyzer)
+		public AnalyzeRequestParameters Analyzer(string analyzer)
 		{
 			this._analyzer = analyzer;
 			this.Add("analyzer", this._analyzer);
@@ -2133,7 +2133,7 @@ public AnalyzeQueryString Analyzer(string analyzer)
 		
 		internal object _field { get; set; }
 		///<summary>Use the analyzer configured for this field (instead of passing the analyzer name)</summary>
-		public AnalyzeQueryString Field(string field)
+		public AnalyzeRequestParameters Field(string field)
 		{
 			this._field = field;
 			this.Add("field", this._field);
@@ -2143,7 +2143,7 @@ public AnalyzeQueryString Field(string field)
 		
 		internal  string[] _filters { get; set; }
 		///<summary>A comma-separated list of filters to use for the analysis</summary>
-		public AnalyzeQueryString Filters(params string[] filters)
+		public AnalyzeRequestParameters Filters(params string[] filters)
 		{
 			this._filters = filters;
 			this.Add("filters", this._filters);
@@ -2153,7 +2153,7 @@ public AnalyzeQueryString Filters(params string[] filters)
 		
 		internal string _index { get; set; }
 		///<summary>The name of the index to scope the operation</summary>
-		public AnalyzeQueryString Index(string index)
+		public AnalyzeRequestParameters Index(string index)
 		{
 			this._index = index;
 			this.Add("index", this._index);
@@ -2163,7 +2163,7 @@ public AnalyzeQueryString Index(string index)
 		
 		internal bool _prefer_local { get; set; }
 		///<summary>With `true`, specify that a local shard should be used if available, with `false`, use a random shard (default: true)</summary>
-		public AnalyzeQueryString PreferLocal(bool prefer_local)
+		public AnalyzeRequestParameters PreferLocal(bool prefer_local)
 		{
 			this._prefer_local = prefer_local;
 			this.Add("prefer_local", this._prefer_local);
@@ -2173,7 +2173,7 @@ public AnalyzeQueryString PreferLocal(bool prefer_local)
 		
 		internal string _text { get; set; }
 		///<summary>The text on which the analysis should be performed (when request body is not used)</summary>
-		public AnalyzeQueryString Text(string text)
+		public AnalyzeRequestParameters Text(string text)
 		{
 			this._text = text;
 			this.Add("text", this._text);
@@ -2183,7 +2183,7 @@ public AnalyzeQueryString Text(string text)
 		
 		internal string _tokenizer { get; set; }
 		///<summary>The name of the tokenizer to use for the analysis</summary>
-		public AnalyzeQueryString Tokenizer(string tokenizer)
+		public AnalyzeRequestParameters Tokenizer(string tokenizer)
 		{
 			this._tokenizer = tokenizer;
 			this.Add("tokenizer", this._tokenizer);
@@ -2193,7 +2193,7 @@ public AnalyzeQueryString Tokenizer(string tokenizer)
 		
 		internal FormatOptions _format { get; set; }
 		///<summary>Format of the output</summary>
-		public AnalyzeQueryString Format(FormatOptions format)
+		public AnalyzeRequestParameters Format(FormatOptions format)
 		{
 			this._format = format;
 			this.Add("format", this._format);
@@ -2208,12 +2208,12 @@ public AnalyzeQueryString Format(FormatOptions format)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html
 	///</pre>
 	///</summary>
-	public class ClearCacheQueryString : FluentQueryString<ClearCacheQueryString> 
+	public class ClearCacheRequestParameters : FluentRequestParameters<ClearCacheRequestParameters> 
 	{
 		
 		internal bool _field_data { get; set; }
 		///<summary>Clear field data</summary>
-		public ClearCacheQueryString FieldData(bool field_data)
+		public ClearCacheRequestParameters FieldData(bool field_data)
 		{
 			this._field_data = field_data;
 			this.Add("field_data", this._field_data);
@@ -2223,7 +2223,7 @@ public ClearCacheQueryString FieldData(bool field_data)
 		
 		internal bool _fielddata { get; set; }
 		///<summary>Clear field data</summary>
-		public ClearCacheQueryString Fielddata(bool fielddata)
+		public ClearCacheRequestParameters Fielddata(bool fielddata)
 		{
 			this._fielddata = fielddata;
 			this.Add("fielddata", this._fielddata);
@@ -2233,7 +2233,7 @@ public ClearCacheQueryString Fielddata(bool fielddata)
 		
 		internal IEnumerable<object> _fields { get; set; }
 		///<summary>A comma-separated list of fields to clear when using the `field_data` parameter (default: all)</summary>
-		public ClearCacheQueryString Fields(params string[] fields)
+		public ClearCacheRequestParameters Fields(params string[] fields)
 		{
 			this._fields = fields.Select(f=>(object)f);
 			this.Add("fields", this._fields);
@@ -2243,7 +2243,7 @@ public ClearCacheQueryString Fields(params string[] fields)
 		
 		internal bool _filter { get; set; }
 		///<summary>Clear filter caches</summary>
-		public ClearCacheQueryString Filter(bool filter)
+		public ClearCacheRequestParameters Filter(bool filter)
 		{
 			this._filter = filter;
 			this.Add("filter", this._filter);
@@ -2253,7 +2253,7 @@ public ClearCacheQueryString Filter(bool filter)
 		
 		internal bool _filter_cache { get; set; }
 		///<summary>Clear filter caches</summary>
-		public ClearCacheQueryString FilterCache(bool filter_cache)
+		public ClearCacheRequestParameters FilterCache(bool filter_cache)
 		{
 			this._filter_cache = filter_cache;
 			this.Add("filter_cache", this._filter_cache);
@@ -2263,7 +2263,7 @@ public ClearCacheQueryString FilterCache(bool filter_cache)
 		
 		internal bool _filter_keys { get; set; }
 		///<summary>A comma-separated list of keys to clear when using the `filter_cache` parameter (default: all)</summary>
-		public ClearCacheQueryString FilterKeys(bool filter_keys)
+		public ClearCacheRequestParameters FilterKeys(bool filter_keys)
 		{
 			this._filter_keys = filter_keys;
 			this.Add("filter_keys", this._filter_keys);
@@ -2273,7 +2273,7 @@ public ClearCacheQueryString FilterKeys(bool filter_keys)
 		
 		internal bool _id { get; set; }
 		///<summary>Clear ID caches for parent/child</summary>
-		public ClearCacheQueryString Id(bool id)
+		public ClearCacheRequestParameters Id(bool id)
 		{
 			this._id = id;
 			this.Add("id", this._id);
@@ -2283,7 +2283,7 @@ public ClearCacheQueryString Id(bool id)
 		
 		internal bool _id_cache { get; set; }
 		///<summary>Clear ID caches for parent/child</summary>
-		public ClearCacheQueryString IdCache(bool id_cache)
+		public ClearCacheRequestParameters IdCache(bool id_cache)
 		{
 			this._id_cache = id_cache;
 			this.Add("id_cache", this._id_cache);
@@ -2293,7 +2293,7 @@ public ClearCacheQueryString IdCache(bool id_cache)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public ClearCacheQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public ClearCacheRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -2303,7 +2303,7 @@ public ClearCacheQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 ClearCacheQueryString AllowNoIndices(bool allow_no_indices)
+		public ClearCacheRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -2313,7 +2313,7 @@ public ClearCacheQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public ClearCacheQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public ClearCacheRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -2323,7 +2323,7 @@ public ClearCacheQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildc
 		
 		internal  string[] _index { get; set; }
 		///<summary>A comma-separated list of index name to limit the operation</summary>
-		public ClearCacheQueryString Index(params string[] index)
+		public ClearCacheRequestParameters Index(params string[] index)
 		{
 			this._index = index;
 			this.Add("index", this._index);
@@ -2333,7 +2333,7 @@ public ClearCacheQueryString Index(params string[] index)
 		
 		internal bool _recycler { get; set; }
 		///<summary>Clear the recycler cache</summary>
-		public ClearCacheQueryString Recycler(bool recycler)
+		public ClearCacheRequestParameters Recycler(bool recycler)
 		{
 			this._recycler = recycler;
 			this.Add("recycler", this._recycler);
@@ -2348,12 +2348,12 @@ public ClearCacheQueryString Recycler(bool recycler)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
 	///</pre>
 	///</summary>
-	public class CloseIndexQueryString : FluentQueryString<CloseIndexQueryString> 
+	public class CloseIndexRequestParameters : FluentRequestParameters<CloseIndexRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public CloseIndexQueryString Timeout(string timeout)
+		public CloseIndexRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -2363,7 +2363,7 @@ public CloseIndexQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public CloseIndexQueryString MasterTimeout(string master_timeout)
+		public CloseIndexRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -2373,7 +2373,7 @@ public CloseIndexQueryString MasterTimeout(string master_timeout)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public CloseIndexQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public CloseIndexRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -2383,7 +2383,7 @@ public CloseIndexQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 CloseIndexQueryString AllowNoIndices(bool allow_no_indices)
+		public CloseIndexRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -2393,7 +2393,7 @@ public CloseIndexQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public CloseIndexQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public CloseIndexRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -2408,12 +2408,12 @@ public CloseIndexQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildc
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-create-index.html
 	///</pre>
 	///</summary>
-	public class CreateIndexQueryString : FluentQueryString<CreateIndexQueryString> 
+	public class CreateIndexRequestParameters : FluentRequestParameters<CreateIndexRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public CreateIndexQueryString Timeout(string timeout)
+		public CreateIndexRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -2423,7 +2423,7 @@ public CreateIndexQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public CreateIndexQueryString MasterTimeout(string master_timeout)
+		public CreateIndexRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -2438,12 +2438,12 @@ public CreateIndexQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html
 	///</pre>
 	///</summary>
-	public class DeleteIndexQueryString : FluentQueryString<DeleteIndexQueryString> 
+	public class DeleteIndexRequestParameters : FluentRequestParameters<DeleteIndexRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public DeleteIndexQueryString Timeout(string timeout)
+		public DeleteIndexRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -2453,7 +2453,7 @@ public DeleteIndexQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public DeleteIndexQueryString MasterTimeout(string master_timeout)
+		public DeleteIndexRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -2468,12 +2468,12 @@ public DeleteIndexQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
 	///</pre>
 	///</summary>
-	public class IndicesDeleteAliasQueryString : FluentQueryString<IndicesDeleteAliasQueryString> 
+	public class IndicesDeleteAliasRequestParameters : FluentRequestParameters<IndicesDeleteAliasRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit timestamp for the document</summary>
-		public IndicesDeleteAliasQueryString Timeout(string timeout)
+		public IndicesDeleteAliasRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -2483,7 +2483,7 @@ public IndicesDeleteAliasQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public IndicesDeleteAliasQueryString MasterTimeout(string master_timeout)
+		public IndicesDeleteAliasRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -2498,12 +2498,12 @@ public IndicesDeleteAliasQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-mapping.html
 	///</pre>
 	///</summary>
-	public class DeleteMappingQueryString : FluentQueryString<DeleteMappingQueryString> 
+	public class DeleteMappingRequestParameters : FluentRequestParameters<DeleteMappingRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public DeleteMappingQueryString MasterTimeout(string master_timeout)
+		public DeleteMappingRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -2518,12 +2518,12 @@ public DeleteMappingQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
 	///</pre>
 	///</summary>
-	public class DeleteTemplateQueryString : FluentQueryString<DeleteTemplateQueryString> 
+	public class DeleteTemplateRequestParameters : FluentRequestParameters<DeleteTemplateRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public DeleteTemplateQueryString Timeout(string timeout)
+		public DeleteTemplateRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -2533,7 +2533,7 @@ public DeleteTemplateQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public DeleteTemplateQueryString MasterTimeout(string master_timeout)
+		public DeleteTemplateRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -2548,12 +2548,12 @@ public DeleteTemplateQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
 	///</pre>
 	///</summary>
-	public class DeleteWarmerQueryString : FluentQueryString<DeleteWarmerQueryString> 
+	public class DeleteWarmerRequestParameters : FluentRequestParameters<DeleteWarmerRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public DeleteWarmerQueryString MasterTimeout(string master_timeout)
+		public DeleteWarmerRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -2568,12 +2568,12 @@ public DeleteWarmerQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html
 	///</pre>
 	///</summary>
-	public class IndexExistsQueryString : FluentQueryString<IndexExistsQueryString> 
+	public class IndexExistsRequestParameters : FluentRequestParameters<IndexExistsRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public IndexExistsQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public IndexExistsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -2583,7 +2583,7 @@ public IndexExistsQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 IndexExistsQueryString AllowNoIndices(bool allow_no_indices)
+		public IndexExistsRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -2593,7 +2593,7 @@ public IndexExistsQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public IndexExistsQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public IndexExistsRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -2603,7 +2603,7 @@ public IndexExistsQueryString ExpandWildcards(ExpandWildcardsOptions expand_wild
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public IndexExistsQueryString Local(bool local)
+		public IndexExistsRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -2618,12 +2618,12 @@ public IndexExistsQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
 	///</pre>
 	///</summary>
-	public class IndicesExistsAliasQueryString : FluentQueryString<IndicesExistsAliasQueryString> 
+	public class IndicesExistsAliasRequestParameters : FluentRequestParameters<IndicesExistsAliasRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public IndicesExistsAliasQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public IndicesExistsAliasRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -2633,7 +2633,7 @@ public IndicesExistsAliasQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 IndicesExistsAliasQueryString AllowNoIndices(bool allow_no_indices)
+		public IndicesExistsAliasRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -2643,7 +2643,7 @@ public IndicesExistsAliasQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public IndicesExistsAliasQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public IndicesExistsAliasRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -2653,7 +2653,7 @@ public IndicesExistsAliasQueryString ExpandWildcards(ExpandWildcardsOptions expa
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public IndicesExistsAliasQueryString Local(bool local)
+		public IndicesExistsAliasRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -2668,12 +2668,12 @@ public IndicesExistsAliasQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
 	///</pre>
 	///</summary>
-	public class IndicesExistsTemplateQueryString : FluentQueryString<IndicesExistsTemplateQueryString> 
+	public class IndicesExistsTemplateRequestParameters : FluentRequestParameters<IndicesExistsTemplateRequestParameters> 
 	{
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public IndicesExistsTemplateQueryString Local(bool local)
+		public IndicesExistsTemplateRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -2688,12 +2688,12 @@ public IndicesExistsTemplateQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-types-exists.html
 	///</pre>
 	///</summary>
-	public class IndicesExistsTypeQueryString : FluentQueryString<IndicesExistsTypeQueryString> 
+	public class IndicesExistsTypeRequestParameters : FluentRequestParameters<IndicesExistsTypeRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public IndicesExistsTypeQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public IndicesExistsTypeRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -2703,7 +2703,7 @@ public IndicesExistsTypeQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 IndicesExistsTypeQueryString AllowNoIndices(bool allow_no_indices)
+		public IndicesExistsTypeRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -2713,7 +2713,7 @@ public IndicesExistsTypeQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public IndicesExistsTypeQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public IndicesExistsTypeRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -2723,7 +2723,7 @@ public IndicesExistsTypeQueryString ExpandWildcards(ExpandWildcardsOptions expan
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public IndicesExistsTypeQueryString Local(bool local)
+		public IndicesExistsTypeRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -2738,12 +2738,12 @@ public IndicesExistsTypeQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html
 	///</pre>
 	///</summary>
-	public class FlushQueryString : FluentQueryString<FlushQueryString> 
+	public class FlushRequestParameters : FluentRequestParameters<FlushRequestParameters> 
 	{
 		
 		internal bool _force { get; set; }
 		///<summary>Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)</summary>
-		public FlushQueryString Force(bool force)
+		public FlushRequestParameters Force(bool force)
 		{
 			this._force = force;
 			this.Add("force", this._force);
@@ -2753,7 +2753,7 @@ public FlushQueryString Force(bool force)
 		
 		internal bool _full { get; set; }
 		///<summary>If set to true a new index writer is created and settings that have been changed related to the index writer will be refreshed. Note: if a full flush is required for a setting to take effect this will be part of the settings update process and it not required to be executed by the user. (This setting can be considered as internal)</summary>
-		public FlushQueryString Full(bool full)
+		public FlushRequestParameters Full(bool full)
 		{
 			this._full = full;
 			this.Add("full", this._full);
@@ -2763,7 +2763,7 @@ public FlushQueryString Full(bool full)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public FlushQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public FlushRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -2773,7 +2773,7 @@ public FlushQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 FlushQueryString AllowNoIndices(bool allow_no_indices)
+		public FlushRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -2783,7 +2783,7 @@ public FlushQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public FlushQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public FlushRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -2798,12 +2798,12 @@ public FlushQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
 	///</pre>
 	///</summary>
-	public class GetAliasesQueryString : FluentQueryString<GetAliasesQueryString> 
+	public class GetAliasesRequestParameters : FluentRequestParameters<GetAliasesRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public GetAliasesQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public GetAliasesRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -2813,7 +2813,7 @@ public GetAliasesQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 GetAliasesQueryString AllowNoIndices(bool allow_no_indices)
+		public GetAliasesRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -2823,7 +2823,7 @@ public GetAliasesQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public GetAliasesQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public GetAliasesRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -2833,7 +2833,7 @@ public GetAliasesQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildc
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public GetAliasesQueryString Local(bool local)
+		public GetAliasesRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -2848,12 +2848,12 @@ public GetAliasesQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
 	///</pre>
 	///</summary>
-	public class IndicesGetAliasesQueryString : FluentQueryString<IndicesGetAliasesQueryString> 
+	public class IndicesGetAliasesRequestParameters : FluentRequestParameters<IndicesGetAliasesRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public IndicesGetAliasesQueryString Timeout(string timeout)
+		public IndicesGetAliasesRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -2863,7 +2863,7 @@ public IndicesGetAliasesQueryString Timeout(string timeout)
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public IndicesGetAliasesQueryString Local(bool local)
+		public IndicesGetAliasesRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -2878,12 +2878,12 @@ public IndicesGetAliasesQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html
 	///</pre>
 	///</summary>
-	public class IndicesGetFieldMappingQueryString : FluentQueryString<IndicesGetFieldMappingQueryString> 
+	public class IndicesGetFieldMappingRequestParameters : FluentRequestParameters<IndicesGetFieldMappingRequestParameters> 
 	{
 		
 		internal bool _include_defaults { get; set; }
 		///<summary>Whether the default mapping values should be returned as well</summary>
-		public IndicesGetFieldMappingQueryString IncludeDefaults(bool include_defaults)
+		public IndicesGetFieldMappingRequestParameters IncludeDefaults(bool include_defaults)
 		{
 			this._include_defaults = include_defaults;
 			this.Add("include_defaults", this._include_defaults);
@@ -2893,7 +2893,7 @@ public IndicesGetFieldMappingQueryString IncludeDefaults(bool include_defaults)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public IndicesGetFieldMappingQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public IndicesGetFieldMappingRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -2903,7 +2903,7 @@ public IndicesGetFieldMappingQueryString IgnoreUnavailable(bool ignore_unavailab
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 IndicesGetFieldMappingQueryString AllowNoIndices(bool allow_no_indices)
+		public IndicesGetFieldMappingRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -2913,7 +2913,7 @@ public IndicesGetFieldMappingQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public IndicesGetFieldMappingQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public IndicesGetFieldMappingRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -2923,7 +2923,7 @@ public IndicesGetFieldMappingQueryString ExpandWildcards(ExpandWildcardsOptions
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public IndicesGetFieldMappingQueryString Local(bool local)
+		public IndicesGetFieldMappingRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -2938,12 +2938,12 @@ public IndicesGetFieldMappingQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
 	///</pre>
 	///</summary>
-	public class GetMappingQueryString : FluentQueryString<GetMappingQueryString> 
+	public class GetMappingRequestParameters : FluentRequestParameters<GetMappingRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public GetMappingQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public GetMappingRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -2953,7 +2953,7 @@ public GetMappingQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 GetMappingQueryString AllowNoIndices(bool allow_no_indices)
+		public GetMappingRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -2963,7 +2963,7 @@ public GetMappingQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public GetMappingQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public GetMappingRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -2973,7 +2973,7 @@ public GetMappingQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildc
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public GetMappingQueryString Local(bool local)
+		public GetMappingRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -2988,12 +2988,12 @@ public GetMappingQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html
 	///</pre>
 	///</summary>
-	public class GetIndexSettingsQueryString : FluentQueryString<GetIndexSettingsQueryString> 
+	public class GetIndexSettingsRequestParameters : FluentRequestParameters<GetIndexSettingsRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public GetIndexSettingsQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public GetIndexSettingsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3003,7 +3003,7 @@ public GetIndexSettingsQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 GetIndexSettingsQueryString AllowNoIndices(bool allow_no_indices)
+		public GetIndexSettingsRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3013,7 +3013,7 @@ public GetIndexSettingsQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public GetIndexSettingsQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public GetIndexSettingsRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3023,7 +3023,7 @@ public GetIndexSettingsQueryString ExpandWildcards(ExpandWildcardsOptions expand
 		
 		internal bool _flat_settings { get; set; }
 		///<summary>Return settings in flat format (default: false)</summary>
-		public GetIndexSettingsQueryString FlatSettings(bool flat_settings)
+		public GetIndexSettingsRequestParameters FlatSettings(bool flat_settings)
 		{
 			this._flat_settings = flat_settings;
 			this.Add("flat_settings", this._flat_settings);
@@ -3033,7 +3033,7 @@ public GetIndexSettingsQueryString FlatSettings(bool flat_settings)
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public GetIndexSettingsQueryString Local(bool local)
+		public GetIndexSettingsRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -3048,12 +3048,12 @@ public GetIndexSettingsQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
 	///</pre>
 	///</summary>
-	public class GetTemplateQueryString : FluentQueryString<GetTemplateQueryString> 
+	public class GetTemplateRequestParameters : FluentRequestParameters<GetTemplateRequestParameters> 
 	{
 		
 		internal bool _flat_settings { get; set; }
 		///<summary>Return settings in flat format (default: false)</summary>
-		public GetTemplateQueryString FlatSettings(bool flat_settings)
+		public GetTemplateRequestParameters FlatSettings(bool flat_settings)
 		{
 			this._flat_settings = flat_settings;
 			this.Add("flat_settings", this._flat_settings);
@@ -3063,7 +3063,7 @@ public GetTemplateQueryString FlatSettings(bool flat_settings)
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public GetTemplateQueryString Local(bool local)
+		public GetTemplateRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -3078,12 +3078,12 @@ public GetTemplateQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
 	///</pre>
 	///</summary>
-	public class GetWarmerQueryString : FluentQueryString<GetWarmerQueryString> 
+	public class GetWarmerRequestParameters : FluentRequestParameters<GetWarmerRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public GetWarmerQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public GetWarmerRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3093,7 +3093,7 @@ public GetWarmerQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 GetWarmerQueryString AllowNoIndices(bool allow_no_indices)
+		public GetWarmerRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3103,7 +3103,7 @@ public GetWarmerQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public GetWarmerQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public GetWarmerRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3113,7 +3113,7 @@ public GetWarmerQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildca
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public GetWarmerQueryString Local(bool local)
+		public GetWarmerRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -3128,12 +3128,12 @@ public GetWarmerQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html
 	///</pre>
 	///</summary>
-	public class OpenIndexQueryString : FluentQueryString<OpenIndexQueryString> 
+	public class OpenIndexRequestParameters : FluentRequestParameters<OpenIndexRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public OpenIndexQueryString Timeout(string timeout)
+		public OpenIndexRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -3143,7 +3143,7 @@ public OpenIndexQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public OpenIndexQueryString MasterTimeout(string master_timeout)
+		public OpenIndexRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -3153,7 +3153,7 @@ public OpenIndexQueryString MasterTimeout(string master_timeout)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public OpenIndexQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public OpenIndexRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3163,7 +3163,7 @@ public OpenIndexQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 OpenIndexQueryString AllowNoIndices(bool allow_no_indices)
+		public OpenIndexRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3173,7 +3173,7 @@ public OpenIndexQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public OpenIndexQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public OpenIndexRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3188,12 +3188,12 @@ public OpenIndexQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildca
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html
 	///</pre>
 	///</summary>
-	public class OptimizeQueryString : FluentQueryString<OptimizeQueryString> 
+	public class OptimizeRequestParameters : FluentRequestParameters<OptimizeRequestParameters> 
 	{
 		
 		internal bool _flush { get; set; }
 		///<summary>Specify whether the index should be flushed after performing the operation (default: true)</summary>
-		public OptimizeQueryString Flush(bool flush)
+		public OptimizeRequestParameters Flush(bool flush)
 		{
 			this._flush = flush;
 			this.Add("flush", this._flush);
@@ -3203,7 +3203,7 @@ public OptimizeQueryString Flush(bool flush)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public OptimizeQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public OptimizeRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3213,7 +3213,7 @@ public OptimizeQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 OptimizeQueryString AllowNoIndices(bool allow_no_indices)
+		public OptimizeRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3223,7 +3223,7 @@ public OptimizeQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public OptimizeQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public OptimizeRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3233,7 +3233,7 @@ public OptimizeQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcar
 		
 		internal int _max_num_segments { get; set; }
 		///<summary>The number of segments the index should be merged into (default: dynamic)</summary>
-		public OptimizeQueryString MaxNumSegments(int max_num_segments)
+		public OptimizeRequestParameters MaxNumSegments(int max_num_segments)
 		{
 			this._max_num_segments = max_num_segments;
 			this.Add("max_num_segments", this._max_num_segments);
@@ -3243,7 +3243,7 @@ public OptimizeQueryString MaxNumSegments(int max_num_segments)
 		
 		internal bool _only_expunge_deletes { get; set; }
 		///<summary>Specify whether the operation should only expunge deleted documents</summary>
-		public OptimizeQueryString OnlyExpungeDeletes(bool only_expunge_deletes)
+		public OptimizeRequestParameters OnlyExpungeDeletes(bool only_expunge_deletes)
 		{
 			this._only_expunge_deletes = only_expunge_deletes;
 			this.Add("only_expunge_deletes", this._only_expunge_deletes);
@@ -3253,7 +3253,7 @@ public OptimizeQueryString OnlyExpungeDeletes(bool only_expunge_deletes)
 		
 		internal string _operation_threading { get; set; }
 		///<summary>TODO: ?</summary>
-		public OptimizeQueryString OperationThreading(string operation_threading)
+		public OptimizeRequestParameters OperationThreading(string operation_threading)
 		{
 			this._operation_threading = operation_threading;
 			this.Add("operation_threading", this._operation_threading);
@@ -3263,7 +3263,7 @@ public OptimizeQueryString OperationThreading(string operation_threading)
 		
 		internal bool _wait_for_merge { get; set; }
 		///<summary>Specify whether the request should block until the merge process is finished (default: true)</summary>
-		public OptimizeQueryString WaitForMerge(bool wait_for_merge)
+		public OptimizeRequestParameters WaitForMerge(bool wait_for_merge)
 		{
 			this._wait_for_merge = wait_for_merge;
 			this.Add("wait_for_merge", this._wait_for_merge);
@@ -3278,12 +3278,12 @@ public OptimizeQueryString WaitForMerge(bool wait_for_merge)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
 	///</pre>
 	///</summary>
-	public class IndicesPutAliasQueryString : FluentQueryString<IndicesPutAliasQueryString> 
+	public class IndicesPutAliasRequestParameters : FluentRequestParameters<IndicesPutAliasRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit timestamp for the document</summary>
-		public IndicesPutAliasQueryString Timeout(string timeout)
+		public IndicesPutAliasRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -3293,7 +3293,7 @@ public IndicesPutAliasQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public IndicesPutAliasQueryString MasterTimeout(string master_timeout)
+		public IndicesPutAliasRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -3308,12 +3308,12 @@ public IndicesPutAliasQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-put-mapping.html
 	///</pre>
 	///</summary>
-	public class PutMappingQueryString : FluentQueryString<PutMappingQueryString> 
+	public class PutMappingRequestParameters : FluentRequestParameters<PutMappingRequestParameters> 
 	{
 		
 		internal bool _ignore_conflicts { get; set; }
 		///<summary>Specify whether to ignore conflicts while updating the mapping (default: false)</summary>
-		public PutMappingQueryString IgnoreConflicts(bool ignore_conflicts)
+		public PutMappingRequestParameters IgnoreConflicts(bool ignore_conflicts)
 		{
 			this._ignore_conflicts = ignore_conflicts;
 			this.Add("ignore_conflicts", this._ignore_conflicts);
@@ -3323,7 +3323,7 @@ public PutMappingQueryString IgnoreConflicts(bool ignore_conflicts)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public PutMappingQueryString Timeout(string timeout)
+		public PutMappingRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -3333,7 +3333,7 @@ public PutMappingQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public PutMappingQueryString MasterTimeout(string master_timeout)
+		public PutMappingRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -3343,7 +3343,7 @@ public PutMappingQueryString MasterTimeout(string master_timeout)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public PutMappingQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public PutMappingRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3353,7 +3353,7 @@ public PutMappingQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 PutMappingQueryString AllowNoIndices(bool allow_no_indices)
+		public PutMappingRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3363,7 +3363,7 @@ public PutMappingQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public PutMappingQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public PutMappingRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3378,12 +3378,12 @@ public PutMappingQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildc
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html
 	///</pre>
 	///</summary>
-	public class UpdateSettingsQueryString : FluentQueryString<UpdateSettingsQueryString> 
+	public class UpdateSettingsRequestParameters : FluentRequestParameters<UpdateSettingsRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public UpdateSettingsQueryString MasterTimeout(string master_timeout)
+		public UpdateSettingsRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -3393,7 +3393,7 @@ public UpdateSettingsQueryString MasterTimeout(string master_timeout)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public UpdateSettingsQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public UpdateSettingsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3403,7 +3403,7 @@ public UpdateSettingsQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 UpdateSettingsQueryString AllowNoIndices(bool allow_no_indices)
+		public UpdateSettingsRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3413,7 +3413,7 @@ public UpdateSettingsQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public UpdateSettingsQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public UpdateSettingsRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3423,7 +3423,7 @@ public UpdateSettingsQueryString ExpandWildcards(ExpandWildcardsOptions expand_w
 		
 		internal bool _flat_settings { get; set; }
 		///<summary>Return settings in flat format (default: false)</summary>
-		public UpdateSettingsQueryString FlatSettings(bool flat_settings)
+		public UpdateSettingsRequestParameters FlatSettings(bool flat_settings)
 		{
 			this._flat_settings = flat_settings;
 			this.Add("flat_settings", this._flat_settings);
@@ -3438,12 +3438,12 @@ public UpdateSettingsQueryString FlatSettings(bool flat_settings)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html
 	///</pre>
 	///</summary>
-	public class PutTemplateQueryString : FluentQueryString<PutTemplateQueryString> 
+	public class PutTemplateRequestParameters : FluentRequestParameters<PutTemplateRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public PutTemplateQueryString Timeout(string timeout)
+		public PutTemplateRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -3453,7 +3453,7 @@ public PutTemplateQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public PutTemplateQueryString MasterTimeout(string master_timeout)
+		public PutTemplateRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -3463,7 +3463,7 @@ public PutTemplateQueryString MasterTimeout(string master_timeout)
 		
 		internal bool _flat_settings { get; set; }
 		///<summary>Return settings in flat format (default: false)</summary>
-		public PutTemplateQueryString FlatSettings(bool flat_settings)
+		public PutTemplateRequestParameters FlatSettings(bool flat_settings)
 		{
 			this._flat_settings = flat_settings;
 			this.Add("flat_settings", this._flat_settings);
@@ -3478,12 +3478,12 @@ public PutTemplateQueryString FlatSettings(bool flat_settings)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html
 	///</pre>
 	///</summary>
-	public class PutWarmerQueryString : FluentQueryString<PutWarmerQueryString> 
+	public class PutWarmerRequestParameters : FluentRequestParameters<PutWarmerRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public PutWarmerQueryString MasterTimeout(string master_timeout)
+		public PutWarmerRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -3493,7 +3493,7 @@ public PutWarmerQueryString MasterTimeout(string master_timeout)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed) in the search request to warm</summary>
-		public PutWarmerQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public PutWarmerRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3503,7 +3503,7 @@ public PutWarmerQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<summary>Whether to ignore if a wildcard indices expression resolves into no concrete indices in the search request to warm. (This includes `_all` string or when no indices have been specified)</summary>
-		public PutWarmerQueryString AllowNoIndices(bool allow_no_indices)
+		public PutWarmerRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3513,7 +3513,7 @@ public PutWarmerQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both, in the search request to warm.</summary>
-		public PutWarmerQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public PutWarmerRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3528,12 +3528,12 @@ public PutWarmerQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildca
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html
 	///</pre>
 	///</summary>
-	public class RefreshQueryString : FluentQueryString<RefreshQueryString> 
+	public class RefreshRequestParameters : FluentRequestParameters<RefreshRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public RefreshQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public RefreshRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3543,7 +3543,7 @@ public RefreshQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 RefreshQueryString AllowNoIndices(bool allow_no_indices)
+		public RefreshRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3553,7 +3553,7 @@ public RefreshQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public RefreshQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public RefreshRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3563,7 +3563,7 @@ public RefreshQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcard
 		
 		internal bool _force { get; set; }
 		///<summary>Force a refresh even if not required</summary>
-		public RefreshQueryString Force(bool force)
+		public RefreshRequestParameters Force(bool force)
 		{
 			this._force = force;
 			this.Add("force", this._force);
@@ -3573,7 +3573,7 @@ public RefreshQueryString Force(bool force)
 		
 		internal string _operation_threading { get; set; }
 		///<summary>TODO: ?</summary>
-		public RefreshQueryString OperationThreading(string operation_threading)
+		public RefreshRequestParameters OperationThreading(string operation_threading)
 		{
 			this._operation_threading = operation_threading;
 			this.Add("operation_threading", this._operation_threading);
@@ -3588,12 +3588,12 @@ public RefreshQueryString OperationThreading(string operation_threading)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html
 	///</pre>
 	///</summary>
-	public class SegmentsQueryString : FluentQueryString<SegmentsQueryString> 
+	public class SegmentsRequestParameters : FluentRequestParameters<SegmentsRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public SegmentsQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public SegmentsRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3603,7 +3603,7 @@ public SegmentsQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 SegmentsQueryString AllowNoIndices(bool allow_no_indices)
+		public SegmentsRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3613,7 +3613,7 @@ public SegmentsQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public SegmentsQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public SegmentsRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3623,7 +3623,7 @@ public SegmentsQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcar
 		
 		internal bool _human { get; set; }
 		///<summary>Whether to return time and byte values in human-readable format.</summary>
-		public SegmentsQueryString Human(bool human)
+		public SegmentsRequestParameters Human(bool human)
 		{
 			this._human = human;
 			this.Add("human", this._human);
@@ -3633,7 +3633,7 @@ public SegmentsQueryString Human(bool human)
 		
 		internal string _operation_threading { get; set; }
 		///<summary>TODO: ?</summary>
-		public SegmentsQueryString OperationThreading(string operation_threading)
+		public SegmentsRequestParameters OperationThreading(string operation_threading)
 		{
 			this._operation_threading = operation_threading;
 			this.Add("operation_threading", this._operation_threading);
@@ -3648,12 +3648,12 @@ public SegmentsQueryString OperationThreading(string operation_threading)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html
 	///</pre>
 	///</summary>
-	public class SnapshotQueryString : FluentQueryString<SnapshotQueryString> 
+	public class SnapshotRequestParameters : FluentRequestParameters<SnapshotRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public SnapshotQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public SnapshotRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3663,7 +3663,7 @@ public SnapshotQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 SnapshotQueryString AllowNoIndices(bool allow_no_indices)
+		public SnapshotRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3673,7 +3673,7 @@ public SnapshotQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public SnapshotQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public SnapshotRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3688,12 +3688,12 @@ public SnapshotQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcar
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html
 	///</pre>
 	///</summary>
-	public class IndicesStatsQueryString : FluentQueryString<IndicesStatsQueryString> 
+	public class IndicesStatsRequestParameters : FluentRequestParameters<IndicesStatsRequestParameters> 
 	{
 		
 		internal IEnumerable<object> _completion_fields { get; set; }
 		///<summary>A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)</summary>
-		public IndicesStatsQueryString CompletionFields(params string[] completion_fields)
+		public IndicesStatsRequestParameters CompletionFields(params string[] completion_fields)
 		{
 			this._completion_fields = completion_fields.Select(f=>(object)f);
 			this.Add("completion_fields", this._completion_fields);
@@ -3703,7 +3703,7 @@ public IndicesStatsQueryString CompletionFields(params string[] completion_field
 		
 		internal IEnumerable<object> _fielddata_fields { get; set; }
 		///<summary>A comma-separated list of fields for `fielddata` index metric (supports wildcards)</summary>
-		public IndicesStatsQueryString FielddataFields(params string[] fielddata_fields)
+		public IndicesStatsRequestParameters FielddataFields(params string[] fielddata_fields)
 		{
 			this._fielddata_fields = fielddata_fields.Select(f=>(object)f);
 			this.Add("fielddata_fields", this._fielddata_fields);
@@ -3713,7 +3713,7 @@ public IndicesStatsQueryString FielddataFields(params string[] fielddata_fields)
 		
 		internal IEnumerable<object> _fields { get; set; }
 		///<summary>A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)</summary>
-		public IndicesStatsQueryString Fields(params string[] fields)
+		public IndicesStatsRequestParameters Fields(params string[] fields)
 		{
 			this._fields = fields.Select(f=>(object)f);
 			this.Add("fields", this._fields);
@@ -3723,7 +3723,7 @@ public IndicesStatsQueryString Fields(params string[] fields)
 		
 		internal bool _groups { get; set; }
 		///<summary>A comma-separated list of search groups for `search` index metric</summary>
-		public IndicesStatsQueryString Groups(bool groups)
+		public IndicesStatsRequestParameters Groups(bool groups)
 		{
 			this._groups = groups;
 			this.Add("groups", this._groups);
@@ -3733,7 +3733,7 @@ public IndicesStatsQueryString Groups(bool groups)
 		
 		internal bool _human { get; set; }
 		///<summary>Whether to return time and byte values in human-readable format.</summary>
-		public IndicesStatsQueryString Human(bool human)
+		public IndicesStatsRequestParameters Human(bool human)
 		{
 			this._human = human;
 			this.Add("human", this._human);
@@ -3743,7 +3743,7 @@ public IndicesStatsQueryString Human(bool human)
 		
 		internal LevelOptions _level { get; set; }
 		///<summary>Return stats aggregated at cluster, index or shard level</summary>
-		public IndicesStatsQueryString Level(LevelOptions level)
+		public IndicesStatsRequestParameters Level(LevelOptions level)
 		{
 			this._level = level;
 			this.Add("level", this._level);
@@ -3753,7 +3753,7 @@ public IndicesStatsQueryString Level(LevelOptions level)
 		
 		internal  string[] _types { get; set; }
 		///<summary>A comma-separated list of document types for the `indexing` index metric</summary>
-		public IndicesStatsQueryString Types(params string[] types)
+		public IndicesStatsRequestParameters Types(params string[] types)
 		{
 			this._types = types;
 			this.Add("types", this._types);
@@ -3768,12 +3768,12 @@ public IndicesStatsQueryString Types(params string[] types)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html
 	///</pre>
 	///</summary>
-	public class IndicesStatusQueryString : FluentQueryString<IndicesStatusQueryString> 
+	public class IndicesStatusRequestParameters : FluentRequestParameters<IndicesStatusRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public IndicesStatusQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public IndicesStatusRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3783,7 +3783,7 @@ public IndicesStatusQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 IndicesStatusQueryString AllowNoIndices(bool allow_no_indices)
+		public IndicesStatusRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3793,7 +3793,7 @@ public IndicesStatusQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public IndicesStatusQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public IndicesStatusRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3803,7 +3803,7 @@ public IndicesStatusQueryString ExpandWildcards(ExpandWildcardsOptions expand_wi
 		
 		internal bool _human { get; set; }
 		///<summary>Whether to return time and byte values in human-readable format.</summary>
-		public IndicesStatusQueryString Human(bool human)
+		public IndicesStatusRequestParameters Human(bool human)
 		{
 			this._human = human;
 			this.Add("human", this._human);
@@ -3813,7 +3813,7 @@ public IndicesStatusQueryString Human(bool human)
 		
 		internal string _operation_threading { get; set; }
 		///<summary>TODO: ?</summary>
-		public IndicesStatusQueryString OperationThreading(string operation_threading)
+		public IndicesStatusRequestParameters OperationThreading(string operation_threading)
 		{
 			this._operation_threading = operation_threading;
 			this.Add("operation_threading", this._operation_threading);
@@ -3823,7 +3823,7 @@ public IndicesStatusQueryString OperationThreading(string operation_threading)
 		
 		internal bool _recovery { get; set; }
 		///<summary>Return information about shard recovery</summary>
-		public IndicesStatusQueryString Recovery(bool recovery)
+		public IndicesStatusRequestParameters Recovery(bool recovery)
 		{
 			this._recovery = recovery;
 			this.Add("recovery", this._recovery);
@@ -3833,7 +3833,7 @@ public IndicesStatusQueryString Recovery(bool recovery)
 		
 		internal bool _snapshot { get; set; }
 		///<summary>TODO: ?</summary>
-		public IndicesStatusQueryString Snapshot(bool snapshot)
+		public IndicesStatusRequestParameters Snapshot(bool snapshot)
 		{
 			this._snapshot = snapshot;
 			this.Add("snapshot", this._snapshot);
@@ -3848,12 +3848,12 @@ public IndicesStatusQueryString Snapshot(bool snapshot)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html
 	///</pre>
 	///</summary>
-	public class AliasQueryString : FluentQueryString<AliasQueryString> 
+	public class AliasRequestParameters : FluentRequestParameters<AliasRequestParameters> 
 	{
 		
 		internal string _timeout { get; set; }
 		///<summary>Request timeout</summary>
-		public AliasQueryString Timeout(string timeout)
+		public AliasRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -3863,7 +3863,7 @@ public AliasQueryString Timeout(string timeout)
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Specify timeout for connection to master</summary>
-		public AliasQueryString MasterTimeout(string master_timeout)
+		public AliasRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -3878,12 +3878,12 @@ public AliasQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html
 	///</pre>
 	///</summary>
-	public class ValidateQueryQueryString : FluentQueryString<ValidateQueryQueryString> 
+	public class ValidateQueryRequestParameters : FluentRequestParameters<ValidateQueryRequestParameters> 
 	{
 		
 		internal bool _explain { get; set; }
 		///<summary>Return detailed information about the error</summary>
-		public ValidateQueryQueryString Explain(bool explain)
+		public ValidateQueryRequestParameters Explain(bool explain)
 		{
 			this._explain = explain;
 			this.Add("explain", this._explain);
@@ -3893,7 +3893,7 @@ public ValidateQueryQueryString Explain(bool explain)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public ValidateQueryQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public ValidateQueryRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -3903,7 +3903,7 @@ public ValidateQueryQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 ValidateQueryQueryString AllowNoIndices(bool allow_no_indices)
+		public ValidateQueryRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -3913,7 +3913,7 @@ public ValidateQueryQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public ValidateQueryQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public ValidateQueryRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -3923,7 +3923,7 @@ public ValidateQueryQueryString ExpandWildcards(ExpandWildcardsOptions expand_wi
 		
 		internal string _operation_threading { get; set; }
 		///<summary>TODO: ?</summary>
-		public ValidateQueryQueryString OperationThreading(string operation_threading)
+		public ValidateQueryRequestParameters OperationThreading(string operation_threading)
 		{
 			this._operation_threading = operation_threading;
 			this.Add("operation_threading", this._operation_threading);
@@ -3933,7 +3933,7 @@ public ValidateQueryQueryString OperationThreading(string operation_threading)
 		
 		internal string _source { get; set; }
 		///<summary>The URL-encoded query definition (instead of using the request body)</summary>
-		public ValidateQueryQueryString Source(string source)
+		public ValidateQueryRequestParameters Source(string source)
 		{
 			this._source = source;
 			this.Add("source", this._source);
@@ -3943,7 +3943,7 @@ public ValidateQueryQueryString Source(string source)
 		
 		internal string _q { get; set; }
 		///<summary>Query in the Lucene query string syntax</summary>
-		public ValidateQueryQueryString Q(string q)
+		public ValidateQueryRequestParameters Q(string q)
 		{
 			this._q = q;
 			this.Add("q", this._q);
@@ -3958,7 +3958,7 @@ public ValidateQueryQueryString Q(string q)
 	///http://www.elasticsearch.org/guide/
 	///</pre>
 	///</summary>
-	public class InfoQueryString : FluentQueryString<InfoQueryString> 
+	public class InfoRequestParameters : FluentRequestParameters<InfoRequestParameters> 
 	{
 	}
 	
@@ -3968,12 +3968,12 @@ public class InfoQueryString : FluentQueryString<InfoQueryString>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html
 	///</pre>
 	///</summary>
-	public class MultiGetQueryString : FluentQueryString<MultiGetQueryString> 
+	public class MultiGetRequestParameters : FluentRequestParameters<MultiGetRequestParameters> 
 	{
 		
 		internal IEnumerable<object> _fields { get; set; }
 		///<summary>A comma-separated list of fields to return in the response</summary>
-		public MultiGetQueryString Fields(params string[] fields)
+		public MultiGetRequestParameters Fields(params string[] fields)
 		{
 			this._fields = fields.Select(f=>(object)f);
 			this.Add("fields", this._fields);
@@ -3983,7 +3983,7 @@ public MultiGetQueryString Fields(params string[] fields)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public MultiGetQueryString Preference(string preference)
+		public MultiGetRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -3993,7 +3993,7 @@ public MultiGetQueryString Preference(string preference)
 		
 		internal bool _realtime { get; set; }
 		///<summary>Specify whether to perform the operation in realtime or search mode</summary>
-		public MultiGetQueryString Realtime(bool realtime)
+		public MultiGetRequestParameters Realtime(bool realtime)
 		{
 			this._realtime = realtime;
 			this.Add("realtime", this._realtime);
@@ -4003,7 +4003,7 @@ public MultiGetQueryString Realtime(bool realtime)
 		
 		internal bool _refresh { get; set; }
 		///<summary>Refresh the shard containing the document before performing the operation</summary>
-		public MultiGetQueryString Refresh(bool refresh)
+		public MultiGetRequestParameters Refresh(bool refresh)
 		{
 			this._refresh = refresh;
 			this.Add("refresh", this._refresh);
@@ -4013,7 +4013,7 @@ public MultiGetQueryString Refresh(bool refresh)
 		
 		internal  string[] __source { get; set; }
 		///<summary>True or false to return the _source field or not, or a list of fields to return</summary>
-		public MultiGetQueryString Source(params string[] _source)
+		public MultiGetRequestParameters Source(params string[] _source)
 		{
 			this.__source = _source;
 			this.Add("_source", this.__source);
@@ -4023,7 +4023,7 @@ public MultiGetQueryString Source(params string[] _source)
 		
 		internal IEnumerable<object> __source_exclude { get; set; }
 		///<summary>A list of fields to exclude from the returned _source field</summary>
-		public MultiGetQueryString SourceExclude(params string[] _source_exclude)
+		public MultiGetRequestParameters SourceExclude(params string[] _source_exclude)
 		{
 			this.__source_exclude = _source_exclude.Select(f=>(object)f);
 			this.Add("_source_exclude", this.__source_exclude);
@@ -4033,7 +4033,7 @@ public MultiGetQueryString SourceExclude(params string[] _source_exclude)
 		
 		internal IEnumerable<object> __source_include { get; set; }
 		///<summary>A list of fields to extract and return from the _source field</summary>
-		public MultiGetQueryString SourceInclude(params string[] _source_include)
+		public MultiGetRequestParameters SourceInclude(params string[] _source_include)
 		{
 			this.__source_include = _source_include.Select(f=>(object)f);
 			this.Add("_source_include", this.__source_include);
@@ -4048,12 +4048,12 @@ public MultiGetQueryString SourceInclude(params string[] _source_include)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-more-like-this.html
 	///</pre>
 	///</summary>
-	public class MoreLikeThisQueryString : FluentQueryString<MoreLikeThisQueryString> 
+	public class MoreLikeThisRequestParameters : FluentRequestParameters<MoreLikeThisRequestParameters> 
 	{
 		
 		internal double _boost_terms { get; set; }
 		///<summary>The boost factor</summary>
-		public MoreLikeThisQueryString BoostTerms(double boost_terms)
+		public MoreLikeThisRequestParameters BoostTerms(double boost_terms)
 		{
 			this._boost_terms = boost_terms;
 			this.Add("boost_terms", this._boost_terms);
@@ -4063,7 +4063,7 @@ public MoreLikeThisQueryString BoostTerms(double boost_terms)
 		
 		internal int _max_doc_freq { get; set; }
 		///<summary>The word occurrence frequency as count: words with higher occurrence in the corpus will be ignored</summary>
-		public MoreLikeThisQueryString MaxDocFreq(int max_doc_freq)
+		public MoreLikeThisRequestParameters MaxDocFreq(int max_doc_freq)
 		{
 			this._max_doc_freq = max_doc_freq;
 			this.Add("max_doc_freq", this._max_doc_freq);
@@ -4073,7 +4073,7 @@ public MoreLikeThisQueryString MaxDocFreq(int max_doc_freq)
 		
 		internal int _max_query_terms { get; set; }
 		///<summary>The maximum query terms to be included in the generated query</summary>
-		public MoreLikeThisQueryString MaxQueryTerms(int max_query_terms)
+		public MoreLikeThisRequestParameters MaxQueryTerms(int max_query_terms)
 		{
 			this._max_query_terms = max_query_terms;
 			this.Add("max_query_terms", this._max_query_terms);
@@ -4083,7 +4083,7 @@ public MoreLikeThisQueryString MaxQueryTerms(int max_query_terms)
 		
 		internal int _max_word_length { get; set; }
 		///<summary>The minimum length of the word: longer words will be ignored</summary>
-		public MoreLikeThisQueryString MaxWordLength(int max_word_length)
+		public MoreLikeThisRequestParameters MaxWordLength(int max_word_length)
 		{
 			this._max_word_length = max_word_length;
 			this.Add("max_word_length", this._max_word_length);
@@ -4093,7 +4093,7 @@ public MoreLikeThisQueryString MaxWordLength(int max_word_length)
 		
 		internal int _min_doc_freq { get; set; }
 		///<summary>The word occurrence frequency as count: words with lower occurrence in the corpus will be ignored</summary>
-		public MoreLikeThisQueryString MinDocFreq(int min_doc_freq)
+		public MoreLikeThisRequestParameters MinDocFreq(int min_doc_freq)
 		{
 			this._min_doc_freq = min_doc_freq;
 			this.Add("min_doc_freq", this._min_doc_freq);
@@ -4103,7 +4103,7 @@ public MoreLikeThisQueryString MinDocFreq(int min_doc_freq)
 		
 		internal int _min_term_freq { get; set; }
 		///<summary>The term frequency as percent: terms with lower occurence in the source document will be ignored</summary>
-		public MoreLikeThisQueryString MinTermFreq(int min_term_freq)
+		public MoreLikeThisRequestParameters MinTermFreq(int min_term_freq)
 		{
 			this._min_term_freq = min_term_freq;
 			this.Add("min_term_freq", this._min_term_freq);
@@ -4113,7 +4113,7 @@ public MoreLikeThisQueryString MinTermFreq(int min_term_freq)
 		
 		internal int _min_word_length { get; set; }
 		///<summary>The minimum length of the word: shorter words will be ignored</summary>
-		public MoreLikeThisQueryString MinWordLength(int min_word_length)
+		public MoreLikeThisRequestParameters MinWordLength(int min_word_length)
 		{
 			this._min_word_length = min_word_length;
 			this.Add("min_word_length", this._min_word_length);
@@ -4123,7 +4123,7 @@ public MoreLikeThisQueryString MinWordLength(int min_word_length)
 		
 		internal IEnumerable<object> _mlt_fields { get; set; }
 		///<summary>Specific fields to perform the query against</summary>
-		public MoreLikeThisQueryString MltFields(params string[] mlt_fields)
+		public MoreLikeThisRequestParameters MltFields(params string[] mlt_fields)
 		{
 			this._mlt_fields = mlt_fields.Select(f=>(object)f);
 			this.Add("mlt_fields", this._mlt_fields);
@@ -4133,7 +4133,7 @@ public MoreLikeThisQueryString MltFields(params string[] mlt_fields)
 		
 		internal double _percent_terms_to_match { get; set; }
 		///<summary>How many terms have to match in order to consider the document a match (default: 0.3)</summary>
-		public MoreLikeThisQueryString PercentTermsToMatch(double percent_terms_to_match)
+		public MoreLikeThisRequestParameters PercentTermsToMatch(double percent_terms_to_match)
 		{
 			this._percent_terms_to_match = percent_terms_to_match;
 			this.Add("percent_terms_to_match", this._percent_terms_to_match);
@@ -4143,7 +4143,7 @@ public MoreLikeThisQueryString PercentTermsToMatch(double percent_terms_to_match
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public MoreLikeThisQueryString Routing(string routing)
+		public MoreLikeThisRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -4153,7 +4153,7 @@ public MoreLikeThisQueryString Routing(string routing)
 		
 		internal int _search_from { get; set; }
 		///<summary>The offset from which to return results</summary>
-		public MoreLikeThisQueryString SearchFrom(int search_from)
+		public MoreLikeThisRequestParameters SearchFrom(int search_from)
 		{
 			this._search_from = search_from;
 			this.Add("search_from", this._search_from);
@@ -4163,7 +4163,7 @@ public MoreLikeThisQueryString SearchFrom(int search_from)
 		
 		internal  string[] _search_indices { get; set; }
 		///<summary>A comma-separated list of indices to perform the query against (default: the index containing the document)</summary>
-		public MoreLikeThisQueryString SearchIndices(params string[] search_indices)
+		public MoreLikeThisRequestParameters SearchIndices(params string[] search_indices)
 		{
 			this._search_indices = search_indices;
 			this.Add("search_indices", this._search_indices);
@@ -4173,7 +4173,7 @@ public MoreLikeThisQueryString SearchIndices(params string[] search_indices)
 		
 		internal string _search_query_hint { get; set; }
 		///<summary>The search query hint</summary>
-		public MoreLikeThisQueryString SearchQueryHint(string search_query_hint)
+		public MoreLikeThisRequestParameters SearchQueryHint(string search_query_hint)
 		{
 			this._search_query_hint = search_query_hint;
 			this.Add("search_query_hint", this._search_query_hint);
@@ -4183,7 +4183,7 @@ public MoreLikeThisQueryString SearchQueryHint(string search_query_hint)
 		
 		internal string _search_scroll { get; set; }
 		///<summary>A scroll search request definition</summary>
-		public MoreLikeThisQueryString SearchScroll(string search_scroll)
+		public MoreLikeThisRequestParameters SearchScroll(string search_scroll)
 		{
 			this._search_scroll = search_scroll;
 			this.Add("search_scroll", this._search_scroll);
@@ -4193,7 +4193,7 @@ public MoreLikeThisQueryString SearchScroll(string search_scroll)
 		
 		internal int _search_size { get; set; }
 		///<summary>The number of documents to return (default: 10)</summary>
-		public MoreLikeThisQueryString SearchSize(int search_size)
+		public MoreLikeThisRequestParameters SearchSize(int search_size)
 		{
 			this._search_size = search_size;
 			this.Add("search_size", this._search_size);
@@ -4203,7 +4203,7 @@ public MoreLikeThisQueryString SearchSize(int search_size)
 		
 		internal string _search_source { get; set; }
 		///<summary>A specific search request definition (instead of using the request body)</summary>
-		public MoreLikeThisQueryString SearchSource(string search_source)
+		public MoreLikeThisRequestParameters SearchSource(string search_source)
 		{
 			this._search_source = search_source;
 			this.Add("search_source", this._search_source);
@@ -4213,7 +4213,7 @@ public MoreLikeThisQueryString SearchSource(string search_source)
 		
 		internal string _search_type { get; set; }
 		///<summary>Specific search type (eg. `dfs_then_fetch`, `count`, etc)</summary>
-		public MoreLikeThisQueryString SearchType(string search_type)
+		public MoreLikeThisRequestParameters SearchType(string search_type)
 		{
 			this._search_type = search_type;
 			this.Add("search_type", this._search_type);
@@ -4223,7 +4223,7 @@ public MoreLikeThisQueryString SearchType(string search_type)
 		
 		internal  string[] _search_types { get; set; }
 		///<summary>A comma-separated list of types to perform the query against (default: the same type as the document)</summary>
-		public MoreLikeThisQueryString SearchTypes(params string[] search_types)
+		public MoreLikeThisRequestParameters SearchTypes(params string[] search_types)
 		{
 			this._search_types = search_types;
 			this.Add("search_types", this._search_types);
@@ -4233,7 +4233,7 @@ public MoreLikeThisQueryString SearchTypes(params string[] search_types)
 		
 		internal  string[] _stop_words { get; set; }
 		///<summary>A list of stop words to be ignored</summary>
-		public MoreLikeThisQueryString StopWords(params string[] stop_words)
+		public MoreLikeThisRequestParameters StopWords(params string[] stop_words)
 		{
 			this._stop_words = stop_words;
 			this.Add("stop_words", this._stop_words);
@@ -4248,12 +4248,12 @@ public MoreLikeThisQueryString StopWords(params string[] stop_words)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
 	///</pre>
 	///</summary>
-	public class MpercolateQueryString : FluentQueryString<MpercolateQueryString> 
+	public class MpercolateRequestParameters : FluentRequestParameters<MpercolateRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public MpercolateQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public MpercolateRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -4263,7 +4263,7 @@ public MpercolateQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 MpercolateQueryString AllowNoIndices(bool allow_no_indices)
+		public MpercolateRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -4273,7 +4273,7 @@ public MpercolateQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public MpercolateQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public MpercolateRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -4288,12 +4288,12 @@ public MpercolateQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildc
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html
 	///</pre>
 	///</summary>
-	public class MultiSearchQueryString : FluentQueryString<MultiSearchQueryString> 
+	public class MultiSearchRequestParameters : FluentRequestParameters<MultiSearchRequestParameters> 
 	{
 		
 		internal SearchTypeOptions _search_type { get; set; }
 		///<summary>Search operation type</summary>
-		public MultiSearchQueryString SearchType(SearchTypeOptions search_type)
+		public MultiSearchRequestParameters SearchType(SearchTypeOptions search_type)
 		{
 			this._search_type = search_type;
 			this.Add("search_type", this._search_type);
@@ -4308,12 +4308,12 @@ public MultiSearchQueryString SearchType(SearchTypeOptions search_type)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html
 	///</pre>
 	///</summary>
-	public class MtermvectorsQueryString : FluentQueryString<MtermvectorsQueryString> 
+	public class MtermvectorsRequestParameters : FluentRequestParameters<MtermvectorsRequestParameters> 
 	{
 		
 		internal  string[] _ids { get; set; }
 		///<summary>A comma-separated list of documents ids. You must define ids as parameter or set &quot;ids&quot; or &quot;docs&quot; in the request body</summary>
-		public MtermvectorsQueryString Ids(params string[] ids)
+		public MtermvectorsRequestParameters Ids(params string[] ids)
 		{
 			this._ids = ids;
 			this.Add("ids", this._ids);
@@ -4323,7 +4323,7 @@ public MtermvectorsQueryString Ids(params string[] ids)
 		
 		internal bool _term_statistics { get; set; }
 		///<summary>Specifies if total term frequency and document frequency should be returned. Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-		public MtermvectorsQueryString TermStatistics(bool term_statistics)
+		public MtermvectorsRequestParameters TermStatistics(bool term_statistics)
 		{
 			this._term_statistics = term_statistics;
 			this.Add("term_statistics", this._term_statistics);
@@ -4333,7 +4333,7 @@ public MtermvectorsQueryString TermStatistics(bool term_statistics)
 		
 		internal bool _field_statistics { get; set; }
 		///<summary>Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned. Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-		public MtermvectorsQueryString FieldStatistics(bool field_statistics)
+		public MtermvectorsRequestParameters FieldStatistics(bool field_statistics)
 		{
 			this._field_statistics = field_statistics;
 			this.Add("field_statistics", this._field_statistics);
@@ -4343,7 +4343,7 @@ public MtermvectorsQueryString FieldStatistics(bool field_statistics)
 		
 		internal IEnumerable<object> _fields { get; set; }
 		///<summary>A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-		public MtermvectorsQueryString Fields(params string[] fields)
+		public MtermvectorsRequestParameters Fields(params string[] fields)
 		{
 			this._fields = fields.Select(f=>(object)f);
 			this.Add("fields", this._fields);
@@ -4353,7 +4353,7 @@ public MtermvectorsQueryString Fields(params string[] fields)
 		
 		internal bool _offsets { get; set; }
 		///<summary>Specifies if term offsets should be returned. Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-		public MtermvectorsQueryString Offsets(bool offsets)
+		public MtermvectorsRequestParameters Offsets(bool offsets)
 		{
 			this._offsets = offsets;
 			this.Add("offsets", this._offsets);
@@ -4363,7 +4363,7 @@ public MtermvectorsQueryString Offsets(bool offsets)
 		
 		internal bool _positions { get; set; }
 		///<summary>Specifies if term positions should be returned. Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-		public MtermvectorsQueryString Positions(bool positions)
+		public MtermvectorsRequestParameters Positions(bool positions)
 		{
 			this._positions = positions;
 			this.Add("positions", this._positions);
@@ -4373,7 +4373,7 @@ public MtermvectorsQueryString Positions(bool positions)
 		
 		internal bool _payloads { get; set; }
 		///<summary>Specifies if term payloads should be returned. Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-		public MtermvectorsQueryString Payloads(bool payloads)
+		public MtermvectorsRequestParameters Payloads(bool payloads)
 		{
 			this._payloads = payloads;
 			this.Add("payloads", this._payloads);
@@ -4383,7 +4383,7 @@ public MtermvectorsQueryString Payloads(bool payloads)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random) .Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-		public MtermvectorsQueryString Preference(string preference)
+		public MtermvectorsRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -4393,7 +4393,7 @@ public MtermvectorsQueryString Preference(string preference)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value. Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-		public MtermvectorsQueryString Routing(string routing)
+		public MtermvectorsRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -4403,7 +4403,7 @@ public MtermvectorsQueryString Routing(string routing)
 		
 		internal string _parent { get; set; }
 		///<summary>Parent id of documents. Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-		public MtermvectorsQueryString Parent(string parent)
+		public MtermvectorsRequestParameters Parent(string parent)
 		{
 			this._parent = parent;
 			this.Add("parent", this._parent);
@@ -4418,12 +4418,12 @@ public MtermvectorsQueryString Parent(string parent)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html
 	///</pre>
 	///</summary>
-	public class NodesHotThreadsQueryString : FluentQueryString<NodesHotThreadsQueryString> 
+	public class NodesHotThreadsRequestParameters : FluentRequestParameters<NodesHotThreadsRequestParameters> 
 	{
 		
 		internal string _interval { get; set; }
 		///<summary>The interval for the second sampling of threads</summary>
-		public NodesHotThreadsQueryString Interval(string interval)
+		public NodesHotThreadsRequestParameters Interval(string interval)
 		{
 			this._interval = interval;
 			this.Add("interval", this._interval);
@@ -4433,7 +4433,7 @@ public NodesHotThreadsQueryString Interval(string interval)
 		
 		internal int _snapshots { get; set; }
 		///<summary>Number of samples of thread stacktrace (default: 10)</summary>
-		public NodesHotThreadsQueryString Snapshots(int snapshots)
+		public NodesHotThreadsRequestParameters Snapshots(int snapshots)
 		{
 			this._snapshots = snapshots;
 			this.Add("snapshots", this._snapshots);
@@ -4443,7 +4443,7 @@ public NodesHotThreadsQueryString Snapshots(int snapshots)
 		
 		internal int _threads { get; set; }
 		///<summary>Specify the number of threads to provide information for (default: 3)</summary>
-		public NodesHotThreadsQueryString Threads(int threads)
+		public NodesHotThreadsRequestParameters Threads(int threads)
 		{
 			this._threads = threads;
 			this.Add("threads", this._threads);
@@ -4453,7 +4453,7 @@ public NodesHotThreadsQueryString Threads(int threads)
 		
 		internal TypeOptions _type { get; set; }
 		///<summary>The type to sample (default: cpu)</summary>
-		public NodesHotThreadsQueryString Type(TypeOptions type)
+		public NodesHotThreadsRequestParameters Type(TypeOptions type)
 		{
 			this._type = type;
 			this.Add("type", this._type);
@@ -4468,12 +4468,12 @@ public NodesHotThreadsQueryString Type(TypeOptions type)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html
 	///</pre>
 	///</summary>
-	public class NodesInfoQueryString : FluentQueryString<NodesInfoQueryString> 
+	public class NodesInfoRequestParameters : FluentRequestParameters<NodesInfoRequestParameters> 
 	{
 		
 		internal bool _flat_settings { get; set; }
 		///<summary>Return settings in flat format (default: false)</summary>
-		public NodesInfoQueryString FlatSettings(bool flat_settings)
+		public NodesInfoRequestParameters FlatSettings(bool flat_settings)
 		{
 			this._flat_settings = flat_settings;
 			this.Add("flat_settings", this._flat_settings);
@@ -4483,7 +4483,7 @@ public NodesInfoQueryString FlatSettings(bool flat_settings)
 		
 		internal bool _human { get; set; }
 		///<summary>Whether to return time and byte values in human-readable format.</summary>
-		public NodesInfoQueryString Human(bool human)
+		public NodesInfoRequestParameters Human(bool human)
 		{
 			this._human = human;
 			this.Add("human", this._human);
@@ -4498,12 +4498,12 @@ public NodesInfoQueryString Human(bool human)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html
 	///</pre>
 	///</summary>
-	public class NodesShutdownQueryString : FluentQueryString<NodesShutdownQueryString> 
+	public class NodesShutdownRequestParameters : FluentRequestParameters<NodesShutdownRequestParameters> 
 	{
 		
 		internal string _delay { get; set; }
 		///<summary>Set the delay for the operation (default: 1s)</summary>
-		public NodesShutdownQueryString Delay(string delay)
+		public NodesShutdownRequestParameters Delay(string delay)
 		{
 			this._delay = delay;
 			this.Add("delay", this._delay);
@@ -4513,7 +4513,7 @@ public NodesShutdownQueryString Delay(string delay)
 		
 		internal bool _exit { get; set; }
 		///<summary>Exit the JVM as well (default: true)</summary>
-		public NodesShutdownQueryString Exit(bool exit)
+		public NodesShutdownRequestParameters Exit(bool exit)
 		{
 			this._exit = exit;
 			this.Add("exit", this._exit);
@@ -4528,12 +4528,12 @@ public NodesShutdownQueryString Exit(bool exit)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html
 	///</pre>
 	///</summary>
-	public class NodesStatsQueryString : FluentQueryString<NodesStatsQueryString> 
+	public class NodesStatsRequestParameters : FluentRequestParameters<NodesStatsRequestParameters> 
 	{
 		
 		internal IEnumerable<object> _completion_fields { get; set; }
 		///<summary>A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)</summary>
-		public NodesStatsQueryString CompletionFields(params string[] completion_fields)
+		public NodesStatsRequestParameters CompletionFields(params string[] completion_fields)
 		{
 			this._completion_fields = completion_fields.Select(f=>(object)f);
 			this.Add("completion_fields", this._completion_fields);
@@ -4543,7 +4543,7 @@ public NodesStatsQueryString CompletionFields(params string[] completion_fields)
 		
 		internal IEnumerable<object> _fielddata_fields { get; set; }
 		///<summary>A comma-separated list of fields for `fielddata` index metric (supports wildcards)</summary>
-		public NodesStatsQueryString FielddataFields(params string[] fielddata_fields)
+		public NodesStatsRequestParameters FielddataFields(params string[] fielddata_fields)
 		{
 			this._fielddata_fields = fielddata_fields.Select(f=>(object)f);
 			this.Add("fielddata_fields", this._fielddata_fields);
@@ -4553,7 +4553,7 @@ public NodesStatsQueryString FielddataFields(params string[] fielddata_fields)
 		
 		internal IEnumerable<object> _fields { get; set; }
 		///<summary>A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)</summary>
-		public NodesStatsQueryString Fields(params string[] fields)
+		public NodesStatsRequestParameters Fields(params string[] fields)
 		{
 			this._fields = fields.Select(f=>(object)f);
 			this.Add("fields", this._fields);
@@ -4563,7 +4563,7 @@ public NodesStatsQueryString Fields(params string[] fields)
 		
 		internal bool _groups { get; set; }
 		///<summary>A comma-separated list of search groups for `search` index metric</summary>
-		public NodesStatsQueryString Groups(bool groups)
+		public NodesStatsRequestParameters Groups(bool groups)
 		{
 			this._groups = groups;
 			this.Add("groups", this._groups);
@@ -4573,7 +4573,7 @@ public NodesStatsQueryString Groups(bool groups)
 		
 		internal bool _human { get; set; }
 		///<summary>Whether to return time and byte values in human-readable format.</summary>
-		public NodesStatsQueryString Human(bool human)
+		public NodesStatsRequestParameters Human(bool human)
 		{
 			this._human = human;
 			this.Add("human", this._human);
@@ -4583,7 +4583,7 @@ public NodesStatsQueryString Human(bool human)
 		
 		internal LevelOptions _level { get; set; }
 		///<summary>Return indices stats aggregated at node, index or shard level</summary>
-		public NodesStatsQueryString Level(LevelOptions level)
+		public NodesStatsRequestParameters Level(LevelOptions level)
 		{
 			this._level = level;
 			this.Add("level", this._level);
@@ -4593,7 +4593,7 @@ public NodesStatsQueryString Level(LevelOptions level)
 		
 		internal  string[] _types { get; set; }
 		///<summary>A comma-separated list of document types for the `indexing` index metric</summary>
-		public NodesStatsQueryString Types(params string[] types)
+		public NodesStatsRequestParameters Types(params string[] types)
 		{
 			this._types = types;
 			this.Add("types", this._types);
@@ -4608,12 +4608,12 @@ public NodesStatsQueryString Types(params string[] types)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html
 	///</pre>
 	///</summary>
-	public class PercolateQueryString : FluentQueryString<PercolateQueryString> 
+	public class PercolateRequestParameters : FluentRequestParameters<PercolateRequestParameters> 
 	{
 		
 		internal  string[] _routing { get; set; }
 		///<summary>A comma-separated list of specific routing values</summary>
-		public PercolateQueryString Routing(params string[] routing)
+		public PercolateRequestParameters Routing(params string[] routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -4623,7 +4623,7 @@ public PercolateQueryString Routing(params string[] routing)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public PercolateQueryString Preference(string preference)
+		public PercolateRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -4633,7 +4633,7 @@ public PercolateQueryString Preference(string preference)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public PercolateQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public PercolateRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -4643,7 +4643,7 @@ public PercolateQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 PercolateQueryString AllowNoIndices(bool allow_no_indices)
+		public PercolateRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -4653,7 +4653,7 @@ public PercolateQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public PercolateQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public PercolateRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -4663,7 +4663,7 @@ public PercolateQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildca
 		
 		internal string _percolate_index { get; set; }
 		///<summary>The index to percolate the document into. Defaults to index.</summary>
-		public PercolateQueryString PercolateIndex(string percolate_index)
+		public PercolateRequestParameters PercolateIndex(string percolate_index)
 		{
 			this._percolate_index = percolate_index;
 			this.Add("percolate_index", this._percolate_index);
@@ -4673,7 +4673,7 @@ public PercolateQueryString PercolateIndex(string percolate_index)
 		
 		internal string _percolate_type { get; set; }
 		///<summary>The type to percolate document into. Defaults to type.</summary>
-		public PercolateQueryString PercolateType(string percolate_type)
+		public PercolateRequestParameters PercolateType(string percolate_type)
 		{
 			this._percolate_type = percolate_type;
 			this.Add("percolate_type", this._percolate_type);
@@ -4683,7 +4683,7 @@ public PercolateQueryString PercolateType(string percolate_type)
 		
 		internal int _version { get; set; }
 		///<summary>Explicit version number for concurrency control</summary>
-		public PercolateQueryString Version(int version)
+		public PercolateRequestParameters Version(int version)
 		{
 			this._version = version;
 			this.Add("version", this._version);
@@ -4693,7 +4693,7 @@ public PercolateQueryString Version(int version)
 		
 		internal VersionTypeOptions _version_type { get; set; }
 		///<summary>Specific version type</summary>
-		public PercolateQueryString VersionType(VersionTypeOptions version_type)
+		public PercolateRequestParameters VersionType(VersionTypeOptions version_type)
 		{
 			this._version_type = version_type;
 			this.Add("version_type", this._version_type);
@@ -4708,7 +4708,7 @@ public PercolateQueryString VersionType(VersionTypeOptions version_type)
 	///http://www.elasticsearch.org/guide/
 	///</pre>
 	///</summary>
-	public class PingQueryString : FluentQueryString<PingQueryString> 
+	public class PingRequestParameters : FluentRequestParameters<PingRequestParameters> 
 	{
 	}
 	
@@ -4718,12 +4718,12 @@ public class PingQueryString : FluentQueryString<PingQueryString>
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
 	///</pre>
 	///</summary>
-	public class ScrollQueryString : FluentQueryString<ScrollQueryString> 
+	public class ScrollRequestParameters : FluentRequestParameters<ScrollRequestParameters> 
 	{
 		
 		internal string _scroll { get; set; }
 		///<summary>Specify how long a consistent view of the index should be maintained for scrolled search</summary>
-		public ScrollQueryString Scroll(string scroll)
+		public ScrollRequestParameters Scroll(string scroll)
 		{
 			this._scroll = scroll;
 			this.Add("scroll", this._scroll);
@@ -4733,7 +4733,7 @@ public ScrollQueryString Scroll(string scroll)
 		
 		internal string _scroll_id { get; set; }
 		///<summary>The scroll ID for scrolled search</summary>
-		public ScrollQueryString ScrollId(string scroll_id)
+		public ScrollRequestParameters ScrollId(string scroll_id)
 		{
 			this._scroll_id = scroll_id;
 			this.Add("scroll_id", this._scroll_id);
@@ -4748,12 +4748,12 @@ public ScrollQueryString ScrollId(string scroll_id)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
 	///</pre>
 	///</summary>
-	public class SearchQueryString : FluentQueryString<SearchQueryString> 
+	public class SearchRequestParameters : FluentRequestParameters<SearchRequestParameters> 
 	{
 		
 		internal string _analyzer { get; set; }
 		///<summary>The analyzer to use for the query string</summary>
-		public SearchQueryString Analyzer(string analyzer)
+		public SearchRequestParameters Analyzer(string analyzer)
 		{
 			this._analyzer = analyzer;
 			this.Add("analyzer", this._analyzer);
@@ -4763,7 +4763,7 @@ public SearchQueryString Analyzer(string analyzer)
 		
 		internal bool _analyze_wildcard { get; set; }
 		///<summary>Specify whether wildcard and prefix queries should be analyzed (default: false)</summary>
-		public SearchQueryString AnalyzeWildcard(bool analyze_wildcard)
+		public SearchRequestParameters AnalyzeWildcard(bool analyze_wildcard)
 		{
 			this._analyze_wildcard = analyze_wildcard;
 			this.Add("analyze_wildcard", this._analyze_wildcard);
@@ -4773,7 +4773,7 @@ public SearchQueryString AnalyzeWildcard(bool analyze_wildcard)
 		
 		internal DefaultOperatorOptions _default_operator { get; set; }
 		///<summary>The default operator for query string query (AND or OR)</summary>
-		public SearchQueryString DefaultOperator(DefaultOperatorOptions default_operator)
+		public SearchRequestParameters DefaultOperator(DefaultOperatorOptions default_operator)
 		{
 			this._default_operator = default_operator;
 			this.Add("default_operator", this._default_operator);
@@ -4783,7 +4783,7 @@ public SearchQueryString DefaultOperator(DefaultOperatorOptions default_operator
 		
 		internal string _df { get; set; }
 		///<summary>The field to use as default where no field prefix is given in the query string</summary>
-		public SearchQueryString Df(string df)
+		public SearchRequestParameters Df(string df)
 		{
 			this._df = df;
 			this.Add("df", this._df);
@@ -4793,7 +4793,7 @@ public SearchQueryString Df(string df)
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public SearchQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public SearchRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -4803,7 +4803,7 @@ public SearchQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 SearchQueryString AllowNoIndices(bool allow_no_indices)
+		public SearchRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -4813,7 +4813,7 @@ public SearchQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public SearchQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public SearchRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -4823,7 +4823,7 @@ public SearchQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards
 		
 		internal  string[] _indices_boost { get; set; }
 		///<summary>Comma-separated list of index boosts</summary>
-		public SearchQueryString IndicesBoost(params string[] indices_boost)
+		public SearchRequestParameters IndicesBoost(params string[] indices_boost)
 		{
 			this._indices_boost = indices_boost;
 			this.Add("indices_boost", this._indices_boost);
@@ -4833,7 +4833,7 @@ public SearchQueryString IndicesBoost(params string[] indices_boost)
 		
 		internal bool _lenient { get; set; }
 		///<summary>Specify whether format-based query failures (such as providing text to a numeric field) should be ignored</summary>
-		public SearchQueryString Lenient(bool lenient)
+		public SearchRequestParameters Lenient(bool lenient)
 		{
 			this._lenient = lenient;
 			this.Add("lenient", this._lenient);
@@ -4843,7 +4843,7 @@ public SearchQueryString Lenient(bool lenient)
 		
 		internal bool _lowercase_expanded_terms { get; set; }
 		///<summary>Specify whether query terms should be lowercased</summary>
-		public SearchQueryString LowercaseExpandedTerms(bool lowercase_expanded_terms)
+		public SearchRequestParameters LowercaseExpandedTerms(bool lowercase_expanded_terms)
 		{
 			this._lowercase_expanded_terms = lowercase_expanded_terms;
 			this.Add("lowercase_expanded_terms", this._lowercase_expanded_terms);
@@ -4853,7 +4853,7 @@ public SearchQueryString LowercaseExpandedTerms(bool lowercase_expanded_terms)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public SearchQueryString Preference(string preference)
+		public SearchRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -4863,7 +4863,7 @@ public SearchQueryString Preference(string preference)
 		
 		internal  string[] _routing { get; set; }
 		///<summary>A comma-separated list of specific routing values</summary>
-		public SearchQueryString Routing(params string[] routing)
+		public SearchRequestParameters Routing(params string[] routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -4873,7 +4873,7 @@ public SearchQueryString Routing(params string[] routing)
 		
 		internal string _scroll { get; set; }
 		///<summary>Specify how long a consistent view of the index should be maintained for scrolled search</summary>
-		public SearchQueryString Scroll(string scroll)
+		public SearchRequestParameters Scroll(string scroll)
 		{
 			this._scroll = scroll;
 			this.Add("scroll", this._scroll);
@@ -4883,7 +4883,7 @@ public SearchQueryString Scroll(string scroll)
 		
 		internal SearchTypeOptions _search_type { get; set; }
 		///<summary>Search operation type</summary>
-		public SearchQueryString SearchType(SearchTypeOptions search_type)
+		public SearchRequestParameters SearchType(SearchTypeOptions search_type)
 		{
 			this._search_type = search_type;
 			this.Add("search_type", this._search_type);
@@ -4893,7 +4893,7 @@ public SearchQueryString SearchType(SearchTypeOptions search_type)
 		
 		internal string _source { get; set; }
 		///<summary>The URL-encoded request definition using the Query DSL (instead of using request body)</summary>
-		public SearchQueryString Source(string source)
+		public SearchRequestParameters Source(string source)
 		{
 			this._source = source;
 			this.Add("source", this._source);
@@ -4903,7 +4903,7 @@ public SearchQueryString Source(string source)
 		
 		internal  string[] _stats { get; set; }
 		///<summary>Specific &#39;tag&#39; of the request for logging and statistical purposes</summary>
-		public SearchQueryString Stats(params string[] stats)
+		public SearchRequestParameters Stats(params string[] stats)
 		{
 			this._stats = stats;
 			this.Add("stats", this._stats);
@@ -4913,7 +4913,7 @@ public SearchQueryString Stats(params string[] stats)
 		
 		internal object _suggest_field { get; set; }
 		///<summary>Specify which field to use for suggestions</summary>
-		public SearchQueryString SuggestField(string suggest_field)
+		public SearchRequestParameters SuggestField(string suggest_field)
 		{
 			this._suggest_field = suggest_field;
 			this.Add("suggest_field", this._suggest_field);
@@ -4923,7 +4923,7 @@ public SearchQueryString SuggestField(string suggest_field)
 		
 		internal SuggestModeOptions _suggest_mode { get; set; }
 		///<summary>Specify suggest mode</summary>
-		public SearchQueryString SuggestMode(SuggestModeOptions suggest_mode)
+		public SearchRequestParameters SuggestMode(SuggestModeOptions suggest_mode)
 		{
 			this._suggest_mode = suggest_mode;
 			this.Add("suggest_mode", this._suggest_mode);
@@ -4933,7 +4933,7 @@ public SearchQueryString SuggestMode(SuggestModeOptions suggest_mode)
 		
 		internal int _suggest_size { get; set; }
 		///<summary>How many suggestions to return in response</summary>
-		public SearchQueryString SuggestSize(int suggest_size)
+		public SearchRequestParameters SuggestSize(int suggest_size)
 		{
 			this._suggest_size = suggest_size;
 			this.Add("suggest_size", this._suggest_size);
@@ -4943,7 +4943,7 @@ public SearchQueryString SuggestSize(int suggest_size)
 		
 		internal string _suggest_text { get; set; }
 		///<summary>The source text for which the suggestions should be returned</summary>
-		public SearchQueryString SuggestText(string suggest_text)
+		public SearchRequestParameters SuggestText(string suggest_text)
 		{
 			this._suggest_text = suggest_text;
 			this.Add("suggest_text", this._suggest_text);
@@ -4958,12 +4958,12 @@ public SearchQueryString SuggestText(string suggest_text)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
 	///</pre>
 	///</summary>
-	public class SnapshotCreateQueryString : FluentQueryString<SnapshotCreateQueryString> 
+	public class SnapshotCreateRequestParameters : FluentRequestParameters<SnapshotCreateRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public SnapshotCreateQueryString MasterTimeout(string master_timeout)
+		public SnapshotCreateRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -4973,7 +4973,7 @@ public SnapshotCreateQueryString MasterTimeout(string master_timeout)
 		
 		internal bool _wait_for_completion { get; set; }
 		///<summary>Should this request wait until the operation has completed before returning</summary>
-		public SnapshotCreateQueryString WaitForCompletion(bool wait_for_completion)
+		public SnapshotCreateRequestParameters WaitForCompletion(bool wait_for_completion)
 		{
 			this._wait_for_completion = wait_for_completion;
 			this.Add("wait_for_completion", this._wait_for_completion);
@@ -4988,12 +4988,12 @@ public SnapshotCreateQueryString WaitForCompletion(bool wait_for_completion)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
 	///</pre>
 	///</summary>
-	public class SnapshotCreateRepositoryQueryString : FluentQueryString<SnapshotCreateRepositoryQueryString> 
+	public class SnapshotCreateRepositoryRequestParameters : FluentRequestParameters<SnapshotCreateRepositoryRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public SnapshotCreateRepositoryQueryString MasterTimeout(string master_timeout)
+		public SnapshotCreateRepositoryRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -5003,7 +5003,7 @@ public SnapshotCreateRepositoryQueryString MasterTimeout(string master_timeout)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public SnapshotCreateRepositoryQueryString Timeout(string timeout)
+		public SnapshotCreateRepositoryRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -5018,12 +5018,12 @@ public SnapshotCreateRepositoryQueryString Timeout(string timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
 	///</pre>
 	///</summary>
-	public class SnapshotDeleteQueryString : FluentQueryString<SnapshotDeleteQueryString> 
+	public class SnapshotDeleteRequestParameters : FluentRequestParameters<SnapshotDeleteRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public SnapshotDeleteQueryString MasterTimeout(string master_timeout)
+		public SnapshotDeleteRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -5038,12 +5038,12 @@ public SnapshotDeleteQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
 	///</pre>
 	///</summary>
-	public class SnapshotDeleteRepositoryQueryString : FluentQueryString<SnapshotDeleteRepositoryQueryString> 
+	public class SnapshotDeleteRepositoryRequestParameters : FluentRequestParameters<SnapshotDeleteRepositoryRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public SnapshotDeleteRepositoryQueryString MasterTimeout(string master_timeout)
+		public SnapshotDeleteRepositoryRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -5053,7 +5053,7 @@ public SnapshotDeleteRepositoryQueryString MasterTimeout(string master_timeout)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public SnapshotDeleteRepositoryQueryString Timeout(string timeout)
+		public SnapshotDeleteRepositoryRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -5068,12 +5068,12 @@ public SnapshotDeleteRepositoryQueryString Timeout(string timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
 	///</pre>
 	///</summary>
-	public class SnapshotGetQueryString : FluentQueryString<SnapshotGetQueryString> 
+	public class SnapshotGetRequestParameters : FluentRequestParameters<SnapshotGetRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public SnapshotGetQueryString MasterTimeout(string master_timeout)
+		public SnapshotGetRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -5088,12 +5088,12 @@ public SnapshotGetQueryString MasterTimeout(string master_timeout)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
 	///</pre>
 	///</summary>
-	public class SnapshotGetRepositoryQueryString : FluentQueryString<SnapshotGetRepositoryQueryString> 
+	public class SnapshotGetRepositoryRequestParameters : FluentRequestParameters<SnapshotGetRepositoryRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public SnapshotGetRepositoryQueryString MasterTimeout(string master_timeout)
+		public SnapshotGetRepositoryRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -5103,7 +5103,7 @@ public SnapshotGetRepositoryQueryString MasterTimeout(string master_timeout)
 		
 		internal bool _local { get; set; }
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
-		public SnapshotGetRepositoryQueryString Local(bool local)
+		public SnapshotGetRepositoryRequestParameters Local(bool local)
 		{
 			this._local = local;
 			this.Add("local", this._local);
@@ -5118,12 +5118,12 @@ public SnapshotGetRepositoryQueryString Local(bool local)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html
 	///</pre>
 	///</summary>
-	public class SnapshotRestoreQueryString : FluentQueryString<SnapshotRestoreQueryString> 
+	public class SnapshotRestoreRequestParameters : FluentRequestParameters<SnapshotRestoreRequestParameters> 
 	{
 		
 		internal string _master_timeout { get; set; }
 		///<summary>Explicit operation timeout for connection to master node</summary>
-		public SnapshotRestoreQueryString MasterTimeout(string master_timeout)
+		public SnapshotRestoreRequestParameters MasterTimeout(string master_timeout)
 		{
 			this._master_timeout = master_timeout;
 			this.Add("master_timeout", this._master_timeout);
@@ -5133,7 +5133,7 @@ public SnapshotRestoreQueryString MasterTimeout(string master_timeout)
 		
 		internal bool _wait_for_completion { get; set; }
 		///<summary>Should this request wait until the operation has completed before returning</summary>
-		public SnapshotRestoreQueryString WaitForCompletion(bool wait_for_completion)
+		public SnapshotRestoreRequestParameters WaitForCompletion(bool wait_for_completion)
 		{
 			this._wait_for_completion = wait_for_completion;
 			this.Add("wait_for_completion", this._wait_for_completion);
@@ -5148,12 +5148,12 @@ public SnapshotRestoreQueryString WaitForCompletion(bool wait_for_completion)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html
 	///</pre>
 	///</summary>
-	public class SuggestQueryString : FluentQueryString<SuggestQueryString> 
+	public class SuggestRequestParameters : FluentRequestParameters<SuggestRequestParameters> 
 	{
 		
 		internal bool _ignore_unavailable { get; set; }
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
-		public SuggestQueryString IgnoreUnavailable(bool ignore_unavailable)
+		public SuggestRequestParameters IgnoreUnavailable(bool ignore_unavailable)
 		{
 			this._ignore_unavailable = ignore_unavailable;
 			this.Add("ignore_unavailable", this._ignore_unavailable);
@@ -5163,7 +5163,7 @@ public SuggestQueryString IgnoreUnavailable(bool ignore_unavailable)
 		
 		internal bool _allow_no_indices { get; set; }
 		///<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 SuggestQueryString AllowNoIndices(bool allow_no_indices)
+		public SuggestRequestParameters AllowNoIndices(bool allow_no_indices)
 		{
 			this._allow_no_indices = allow_no_indices;
 			this.Add("allow_no_indices", this._allow_no_indices);
@@ -5173,7 +5173,7 @@ public SuggestQueryString AllowNoIndices(bool allow_no_indices)
 		
 		internal ExpandWildcardsOptions _expand_wildcards { get; set; }
 		///<summary>Whether to expand wildcard expression to concrete indices that are open, closed or both.</summary>
-		public SuggestQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
+		public SuggestRequestParameters ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 		{
 			this._expand_wildcards = expand_wildcards;
 			this.Add("expand_wildcards", this._expand_wildcards);
@@ -5183,7 +5183,7 @@ public SuggestQueryString ExpandWildcards(ExpandWildcardsOptions expand_wildcard
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random)</summary>
-		public SuggestQueryString Preference(string preference)
+		public SuggestRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -5193,7 +5193,7 @@ public SuggestQueryString Preference(string preference)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public SuggestQueryString Routing(string routing)
+		public SuggestRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -5203,7 +5203,7 @@ public SuggestQueryString Routing(string routing)
 		
 		internal string _source { get; set; }
 		///<summary>The URL-encoded request definition (instead of using request body)</summary>
-		public SuggestQueryString Source(string source)
+		public SuggestRequestParameters Source(string source)
 		{
 			this._source = source;
 			this.Add("source", this._source);
@@ -5218,12 +5218,12 @@ public SuggestQueryString Source(string source)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-termvectors.html
 	///</pre>
 	///</summary>
-	public class TermvectorQueryString : FluentQueryString<TermvectorQueryString> 
+	public class TermvectorRequestParameters : FluentRequestParameters<TermvectorRequestParameters> 
 	{
 		
 		internal bool _term_statistics { get; set; }
 		///<summary>Specifies if total term frequency and document frequency should be returned.</summary>
-		public TermvectorQueryString TermStatistics(bool term_statistics)
+		public TermvectorRequestParameters TermStatistics(bool term_statistics)
 		{
 			this._term_statistics = term_statistics;
 			this.Add("term_statistics", this._term_statistics);
@@ -5233,7 +5233,7 @@ public TermvectorQueryString TermStatistics(bool term_statistics)
 		
 		internal bool _field_statistics { get; set; }
 		///<summary>Specifies if document count, sum of document frequencies and sum of total term frequencies should be returned.</summary>
-		public TermvectorQueryString FieldStatistics(bool field_statistics)
+		public TermvectorRequestParameters FieldStatistics(bool field_statistics)
 		{
 			this._field_statistics = field_statistics;
 			this.Add("field_statistics", this._field_statistics);
@@ -5243,7 +5243,7 @@ public TermvectorQueryString FieldStatistics(bool field_statistics)
 		
 		internal IEnumerable<object> _fields { get; set; }
 		///<summary>A comma-separated list of fields to return.</summary>
-		public TermvectorQueryString Fields(params string[] fields)
+		public TermvectorRequestParameters Fields(params string[] fields)
 		{
 			this._fields = fields.Select(f=>(object)f);
 			this.Add("fields", this._fields);
@@ -5253,7 +5253,7 @@ public TermvectorQueryString Fields(params string[] fields)
 		
 		internal bool _offsets { get; set; }
 		///<summary>Specifies if term offsets should be returned.</summary>
-		public TermvectorQueryString Offsets(bool offsets)
+		public TermvectorRequestParameters Offsets(bool offsets)
 		{
 			this._offsets = offsets;
 			this.Add("offsets", this._offsets);
@@ -5263,7 +5263,7 @@ public TermvectorQueryString Offsets(bool offsets)
 		
 		internal bool _positions { get; set; }
 		///<summary>Specifies if term positions should be returned.</summary>
-		public TermvectorQueryString Positions(bool positions)
+		public TermvectorRequestParameters Positions(bool positions)
 		{
 			this._positions = positions;
 			this.Add("positions", this._positions);
@@ -5273,7 +5273,7 @@ public TermvectorQueryString Positions(bool positions)
 		
 		internal bool _payloads { get; set; }
 		///<summary>Specifies if term payloads should be returned.</summary>
-		public TermvectorQueryString Payloads(bool payloads)
+		public TermvectorRequestParameters Payloads(bool payloads)
 		{
 			this._payloads = payloads;
 			this.Add("payloads", this._payloads);
@@ -5283,7 +5283,7 @@ public TermvectorQueryString Payloads(bool payloads)
 		
 		internal string _preference { get; set; }
 		///<summary>Specify the node or shard the operation should be performed on (default: random).</summary>
-		public TermvectorQueryString Preference(string preference)
+		public TermvectorRequestParameters Preference(string preference)
 		{
 			this._preference = preference;
 			this.Add("preference", this._preference);
@@ -5293,7 +5293,7 @@ public TermvectorQueryString Preference(string preference)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value.</summary>
-		public TermvectorQueryString Routing(string routing)
+		public TermvectorRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -5303,7 +5303,7 @@ public TermvectorQueryString Routing(string routing)
 		
 		internal string _parent { get; set; }
 		///<summary>Parent id of documents.</summary>
-		public TermvectorQueryString Parent(string parent)
+		public TermvectorRequestParameters Parent(string parent)
 		{
 			this._parent = parent;
 			this.Add("parent", this._parent);
@@ -5318,12 +5318,12 @@ public TermvectorQueryString Parent(string parent)
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-update.html
 	///</pre>
 	///</summary>
-	public class UpdateQueryString : FluentQueryString<UpdateQueryString> 
+	public class UpdateRequestParameters : FluentRequestParameters<UpdateRequestParameters> 
 	{
 		
 		internal ConsistencyOptions _consistency { get; set; }
 		///<summary>Explicit write consistency setting for the operation</summary>
-		public UpdateQueryString Consistency(ConsistencyOptions consistency)
+		public UpdateRequestParameters Consistency(ConsistencyOptions consistency)
 		{
 			this._consistency = consistency;
 			this.Add("consistency", this._consistency);
@@ -5333,7 +5333,7 @@ public UpdateQueryString Consistency(ConsistencyOptions consistency)
 		
 		internal IEnumerable<object> _fields { get; set; }
 		///<summary>A comma-separated list of fields to return in the response</summary>
-		public UpdateQueryString Fields(params string[] fields)
+		public UpdateRequestParameters Fields(params string[] fields)
 		{
 			this._fields = fields.Select(f=>(object)f);
 			this.Add("fields", this._fields);
@@ -5343,7 +5343,7 @@ public UpdateQueryString Fields(params string[] fields)
 		
 		internal string _lang { get; set; }
 		///<summary>The script language (default: mvel)</summary>
-		public UpdateQueryString Lang(string lang)
+		public UpdateRequestParameters Lang(string lang)
 		{
 			this._lang = lang;
 			this.Add("lang", this._lang);
@@ -5353,7 +5353,7 @@ public UpdateQueryString Lang(string lang)
 		
 		internal string _parent { get; set; }
 		///<summary>ID of the parent document</summary>
-		public UpdateQueryString Parent(string parent)
+		public UpdateRequestParameters Parent(string parent)
 		{
 			this._parent = parent;
 			this.Add("parent", this._parent);
@@ -5363,7 +5363,7 @@ public UpdateQueryString Parent(string parent)
 		
 		internal bool _refresh { get; set; }
 		///<summary>Refresh the index after performing the operation</summary>
-		public UpdateQueryString Refresh(bool refresh)
+		public UpdateRequestParameters Refresh(bool refresh)
 		{
 			this._refresh = refresh;
 			this.Add("refresh", this._refresh);
@@ -5373,7 +5373,7 @@ public UpdateQueryString Refresh(bool refresh)
 		
 		internal ReplicationOptions _replication { get; set; }
 		///<summary>Specific replication type</summary>
-		public UpdateQueryString Replication(ReplicationOptions replication)
+		public UpdateRequestParameters Replication(ReplicationOptions replication)
 		{
 			this._replication = replication;
 			this.Add("replication", this._replication);
@@ -5383,7 +5383,7 @@ public UpdateQueryString Replication(ReplicationOptions replication)
 		
 		internal int _retry_on_conflict { get; set; }
 		///<summary>Specify how many times should the operation be retried when a conflict occurs (default: 0)</summary>
-		public UpdateQueryString RetryOnConflict(int retry_on_conflict)
+		public UpdateRequestParameters RetryOnConflict(int retry_on_conflict)
 		{
 			this._retry_on_conflict = retry_on_conflict;
 			this.Add("retry_on_conflict", this._retry_on_conflict);
@@ -5393,7 +5393,7 @@ public UpdateQueryString RetryOnConflict(int retry_on_conflict)
 		
 		internal string _routing { get; set; }
 		///<summary>Specific routing value</summary>
-		public UpdateQueryString Routing(string routing)
+		public UpdateRequestParameters Routing(string routing)
 		{
 			this._routing = routing;
 			this.Add("routing", this._routing);
@@ -5403,7 +5403,7 @@ public UpdateQueryString Routing(string routing)
 		
 		internal string _script { get; set; }
 		///<summary>The URL-encoded script definition (instead of using request body)</summary>
-		public UpdateQueryString Script(string script)
+		public UpdateRequestParameters Script(string script)
 		{
 			this._script = script;
 			this.Add("script", this._script);
@@ -5413,7 +5413,7 @@ public UpdateQueryString Script(string script)
 		
 		internal string _timeout { get; set; }
 		///<summary>Explicit operation timeout</summary>
-		public UpdateQueryString Timeout(string timeout)
+		public UpdateRequestParameters Timeout(string timeout)
 		{
 			this._timeout = timeout;
 			this.Add("timeout", this._timeout);
@@ -5423,7 +5423,7 @@ public UpdateQueryString Timeout(string timeout)
 		
 		internal string _timestamp { get; set; }
 		///<summary>Explicit timestamp for the document</summary>
-		public UpdateQueryString Timestamp(string timestamp)
+		public UpdateRequestParameters Timestamp(string timestamp)
 		{
 			this._timestamp = timestamp;
 			this.Add("timestamp", this._timestamp);
@@ -5433,7 +5433,7 @@ public UpdateQueryString Timestamp(string timestamp)
 		
 		internal string _ttl { get; set; }
 		///<summary>Expiration time for the document</summary>
-		public UpdateQueryString Ttl(string ttl)
+		public UpdateRequestParameters Ttl(string ttl)
 		{
 			this._ttl = ttl;
 			this.Add("ttl", this._ttl);
@@ -5443,7 +5443,7 @@ public UpdateQueryString Ttl(string ttl)
 		
 		internal int _version { get; set; }
 		///<summary>Explicit version number for concurrency control</summary>
-		public UpdateQueryString Version(int version)
+		public UpdateRequestParameters Version(int version)
 		{
 			this._version = version;
 			this.Add("version", this._version);
@@ -5453,7 +5453,7 @@ public UpdateQueryString Version(int version)
 		
 		internal VersionTypeOptions _version_type { get; set; }
 		///<summary>Specific version type</summary>
-		public UpdateQueryString VersionType(VersionTypeOptions version_type)
+		public UpdateRequestParameters VersionType(VersionTypeOptions version_type)
 		{
 			this._version_type = version_type;
 			this.Add("version_type", this._version_type);
diff --git a/src/Elasticsearch.Net/Elasticsearch.Net.csproj b/src/Elasticsearch.Net/Elasticsearch.Net.csproj
index 68891495f50..135e6948157 100644
--- a/src/Elasticsearch.Net/Elasticsearch.Net.csproj
+++ b/src/Elasticsearch.Net/Elasticsearch.Net.csproj
@@ -81,8 +81,8 @@
     <Compile Include="IElasticsearchClient.Generated.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="Domain\Enums.Generated.cs" />
-    <Compile Include="Domain\FluentQueryString.cs" />
-    <Compile Include="Domain\QueryStringParameters.Generated.cs" />
+    <Compile Include="Domain\FluentRequestParameters.cs" />
+    <Compile Include="Domain\RequestParameters.Generated.cs" />
     <Compile Include="Properties\InternalsVisibleTo.cs" />
     <Compile Include="Serialization\IStringifier.cs" />
     <Compile Include="Serialization\ElasticsearchDefaultSerializer.cs" />
diff --git a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
index e13dbc2e20d..f1d09510fb4 100644
--- a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
@@ -29,13 +29,13 @@ public partial class ElasticsearchClient : IElasticsearchClient
 		///<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> Bulk<T>(object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Bulk<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_bulk".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -58,13 +58,13 @@ public ElasticsearchResponse<T> Bulk<T>(object body, Func<BulkQueryString, BulkQ
 		///<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>> BulkAsync<T>(object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_bulk".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -88,13 +88,13 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(object body, Func<BulkQuerySt
 		///<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> Bulk(object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Bulk(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			var url = "_bulk".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -117,13 +117,13 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(object body, Func<BulkQuery
 		///<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>> BulkAsync(object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			var url = "_bulk".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -146,14 +146,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(object body, Fun
 		///<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> Bulk<T>(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Bulk<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -177,14 +177,14 @@ public ElasticsearchResponse<T> Bulk<T>(string index, object body, Func<BulkQuer
 		///<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>> BulkAsync<T>(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -209,14 +209,14 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, object body, Fu
 		///<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> Bulk(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Bulk(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -240,14 +240,14 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(string index, object body,
 		///<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>> BulkAsync(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -271,7 +271,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, ob
 		///<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> Bulk<T>(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Bulk<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -279,7 +279,7 @@ public ElasticsearchResponse<T> Bulk<T>(string index, string type, object body,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -304,7 +304,7 @@ public ElasticsearchResponse<T> Bulk<T>(string index, string type, object body,
 		///<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>> BulkAsync<T>(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -312,7 +312,7 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, string type, ob
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -338,7 +338,7 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, string type, ob
 		///<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> Bulk(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Bulk(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -346,7 +346,7 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -371,7 +371,7 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(string index, string type,
 		///<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>> BulkAsync(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -379,7 +379,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -401,13 +401,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, st
 		///<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> BulkPut<T>(object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> BulkPut<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_bulk".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -430,13 +430,13 @@ public ElasticsearchResponse<T> BulkPut<T>(object body, Func<BulkQueryString, Bu
 		///<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>> BulkPutAsync<T>(object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_bulk".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -460,13 +460,13 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(object body, Func<BulkQuer
 		///<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> BulkPut(object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> BulkPut(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			var url = "_bulk".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -489,13 +489,13 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(object body, Func<BulkQu
 		///<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>> BulkPutAsync(object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			var url = "_bulk".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -518,14 +518,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(object body,
 		///<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> BulkPut<T>(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> BulkPut<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -549,14 +549,14 @@ public ElasticsearchResponse<T> BulkPut<T>(string index, object body, Func<BulkQ
 		///<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>> BulkPutAsync<T>(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -581,14 +581,14 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, object body,
 		///<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> BulkPut(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -612,14 +612,14 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, object bod
 		///<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>> BulkPutAsync(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -643,7 +643,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index,
 		///<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> BulkPut<T>(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> BulkPut<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -651,7 +651,7 @@ public ElasticsearchResponse<T> BulkPut<T>(string index, string type, object bod
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -676,7 +676,7 @@ public ElasticsearchResponse<T> BulkPut<T>(string index, string type, object bod
 		///<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>> BulkPutAsync<T>(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -684,7 +684,7 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -710,7 +710,7 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, string type,
 		///<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> BulkPut(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -718,7 +718,7 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -743,7 +743,7 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, string typ
 		///<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>> BulkPutAsync(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -751,7 +751,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new BulkQueryString());
+				var qs = queryString(new BulkRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -772,13 +772,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index,
 		///<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> CatAliases<T>(Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatAliases<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/aliases";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAliasesQueryString());
+				var qs = queryString(new CatAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -800,13 +800,13 @@ public ElasticsearchResponse<T> CatAliases<T>(Func<CatAliasesQueryString, CatAli
 		///<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>> CatAliasesAsync<T>(Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/aliases";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAliasesQueryString());
+				var qs = queryString(new CatAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -829,13 +829,13 @@ public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(Func<CatAliasesQueryStr
 		///<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> CatAliases(Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null)
 		{
 			var url = "_cat/aliases";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAliasesQueryString());
+				var qs = queryString(new CatAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -857,13 +857,13 @@ public ElasticsearchResponse<DynamicDictionary> CatAliases(Func<CatAliasesQueryS
 		///<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>> CatAliasesAsync(Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null)
 		{
 			var url = "_cat/aliases";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAliasesQueryString());
+				var qs = queryString(new CatAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -885,14 +885,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(Func<CatAl
 		///<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> CatAliases<T>(string name, Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatAliases<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAliasesQueryString());
+				var qs = queryString(new CatAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -915,14 +915,14 @@ public ElasticsearchResponse<T> CatAliases<T>(string name, Func<CatAliasesQueryS
 		///<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>> CatAliasesAsync<T>(string name, Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAliasesQueryString());
+				var qs = queryString(new CatAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -946,14 +946,14 @@ public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(string name, Func<CatAl
 		///<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> CatAliases(string name, Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAliasesQueryString());
+				var qs = queryString(new CatAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -976,14 +976,14 @@ public ElasticsearchResponse<DynamicDictionary> CatAliases(string name, Func<Cat
 		///<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>> CatAliasesAsync(string name, Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAliasesQueryString());
+				var qs = queryString(new CatAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1004,13 +1004,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(string nam
 		///<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> CatAllocation<T>(Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatAllocation<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/allocation";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAllocationQueryString());
+				var qs = queryString(new CatAllocationRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1032,13 +1032,13 @@ public ElasticsearchResponse<T> CatAllocation<T>(Func<CatAllocationQueryString,
 		///<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>> CatAllocationAsync<T>(Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/allocation";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAllocationQueryString());
+				var qs = queryString(new CatAllocationRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1061,13 +1061,13 @@ public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(Func<CatAllocationQu
 		///<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> CatAllocation(Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null)
 		{
 			var url = "_cat/allocation";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAllocationQueryString());
+				var qs = queryString(new CatAllocationRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1089,13 +1089,13 @@ public ElasticsearchResponse<DynamicDictionary> CatAllocation(Func<CatAllocation
 		///<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>> CatAllocationAsync(Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null)
 		{
 			var url = "_cat/allocation";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAllocationQueryString());
+				var qs = queryString(new CatAllocationRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1117,14 +1117,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(Func<Ca
 		///<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> CatAllocation<T>(string node_id, Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatAllocation<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAllocationQueryString());
+				var qs = queryString(new CatAllocationRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1147,14 +1147,14 @@ public ElasticsearchResponse<T> CatAllocation<T>(string node_id, Func<CatAllocat
 		///<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>> CatAllocationAsync<T>(string node_id, Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAllocationQueryString());
+				var qs = queryString(new CatAllocationRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1178,14 +1178,14 @@ public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(string node_id, Func
 		///<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> CatAllocation(string node_id, Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAllocationQueryString());
+				var qs = queryString(new CatAllocationRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1208,14 +1208,14 @@ public ElasticsearchResponse<DynamicDictionary> CatAllocation(string node_id, Fu
 		///<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>> CatAllocationAsync(string node_id, Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatAllocationQueryString());
+				var qs = queryString(new CatAllocationRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1236,13 +1236,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(string
 		///<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> CatCount<T>(Func<CatCountQueryString, CatCountQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatCount<T>(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/count";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatCountQueryString());
+				var qs = queryString(new CatCountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1264,13 +1264,13 @@ public ElasticsearchResponse<T> CatCount<T>(Func<CatCountQueryString, CatCountQu
 		///<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>> CatCountAsync<T>(Func<CatCountQueryString, CatCountQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatCountAsync<T>(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/count";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatCountQueryString());
+				var qs = queryString(new CatCountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1293,13 +1293,13 @@ public Task<ElasticsearchResponse<T>> CatCountAsync<T>(Func<CatCountQueryString,
 		///<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> CatCount(Func<CatCountQueryString, CatCountQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null)
 		{
 			var url = "_cat/count";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatCountQueryString());
+				var qs = queryString(new CatCountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1321,13 +1321,13 @@ public ElasticsearchResponse<DynamicDictionary> CatCount(Func<CatCountQueryStrin
 		///<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>> CatCountAsync(Func<CatCountQueryString, CatCountQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null)
 		{
 			var url = "_cat/count";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatCountQueryString());
+				var qs = queryString(new CatCountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1349,14 +1349,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(Func<CatCoun
 		///<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> CatCount<T>(string index, Func<CatCountQueryString, CatCountQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatCount<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatCountQueryString());
+				var qs = queryString(new CatCountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1379,14 +1379,14 @@ public ElasticsearchResponse<T> CatCount<T>(string index, Func<CatCountQueryStri
 		///<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>> CatCountAsync<T>(string index, Func<CatCountQueryString, CatCountQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatCountAsync<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatCountQueryString());
+				var qs = queryString(new CatCountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1410,14 +1410,14 @@ public Task<ElasticsearchResponse<T>> CatCountAsync<T>(string index, Func<CatCou
 		///<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> CatCount(string index, Func<CatCountQueryString, CatCountQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatCountQueryString());
+				var qs = queryString(new CatCountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1440,14 +1440,14 @@ public ElasticsearchResponse<DynamicDictionary> CatCount(string index, Func<CatC
 		///<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>> CatCountAsync(string index, Func<CatCountQueryString, CatCountQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatCountQueryString());
+				var qs = queryString(new CatCountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1468,13 +1468,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(string index
 		///<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> CatHealth<T>(Func<CatHealthQueryString, CatHealthQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatHealth<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/health";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatHealthQueryString());
+				var qs = queryString(new CatHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1496,13 +1496,13 @@ public ElasticsearchResponse<T> CatHealth<T>(Func<CatHealthQueryString, CatHealt
 		///<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>> CatHealthAsync<T>(Func<CatHealthQueryString, CatHealthQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatHealthAsync<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/health";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatHealthQueryString());
+				var qs = queryString(new CatHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1525,13 +1525,13 @@ public Task<ElasticsearchResponse<T>> CatHealthAsync<T>(Func<CatHealthQueryStrin
 		///<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> CatHealth(Func<CatHealthQueryString, CatHealthQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null)
 		{
 			var url = "_cat/health";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatHealthQueryString());
+				var qs = queryString(new CatHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1553,13 +1553,13 @@ public ElasticsearchResponse<DynamicDictionary> CatHealth(Func<CatHealthQueryStr
 		///<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>> CatHealthAsync(Func<CatHealthQueryString, CatHealthQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null)
 		{
 			var url = "_cat/health";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatHealthQueryString());
+				var qs = queryString(new CatHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1580,13 +1580,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatHealthAsync(Func<CatHea
 		///<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> CatHelp<T>(Func<CatHelpQueryString, CatHelpQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatHelp<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatHelpQueryString());
+				var qs = queryString(new CatHelpRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1608,13 +1608,13 @@ public ElasticsearchResponse<T> CatHelp<T>(Func<CatHelpQueryString, CatHelpQuery
 		///<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>> CatHelpAsync<T>(Func<CatHelpQueryString, CatHelpQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatHelpAsync<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatHelpQueryString());
+				var qs = queryString(new CatHelpRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1637,13 +1637,13 @@ public Task<ElasticsearchResponse<T>> CatHelpAsync<T>(Func<CatHelpQueryString, C
 		///<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> CatHelp(Func<CatHelpQueryString, CatHelpQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null)
 		{
 			var url = "_cat";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatHelpQueryString());
+				var qs = queryString(new CatHelpRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1665,13 +1665,13 @@ public ElasticsearchResponse<DynamicDictionary> CatHelp(Func<CatHelpQueryString,
 		///<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>> CatHelpAsync(Func<CatHelpQueryString, CatHelpQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null)
 		{
 			var url = "_cat";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatHelpQueryString());
+				var qs = queryString(new CatHelpRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1692,13 +1692,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatHelpAsync(Func<CatHelpQ
 		///<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> CatIndices<T>(Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatIndices<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/indices";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatIndicesQueryString());
+				var qs = queryString(new CatIndicesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1720,13 +1720,13 @@ public ElasticsearchResponse<T> CatIndices<T>(Func<CatIndicesQueryString, CatInd
 		///<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>> CatIndicesAsync<T>(Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/indices";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatIndicesQueryString());
+				var qs = queryString(new CatIndicesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1749,13 +1749,13 @@ public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(Func<CatIndicesQueryStr
 		///<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> CatIndices(Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null)
 		{
 			var url = "_cat/indices";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatIndicesQueryString());
+				var qs = queryString(new CatIndicesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1777,13 +1777,13 @@ public ElasticsearchResponse<DynamicDictionary> CatIndices(Func<CatIndicesQueryS
 		///<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>> CatIndicesAsync(Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null)
 		{
 			var url = "_cat/indices";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatIndicesQueryString());
+				var qs = queryString(new CatIndicesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1805,14 +1805,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(Func<CatIn
 		///<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> CatIndices<T>(string index, Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatIndices<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatIndicesQueryString());
+				var qs = queryString(new CatIndicesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1835,14 +1835,14 @@ public ElasticsearchResponse<T> CatIndices<T>(string index, Func<CatIndicesQuery
 		///<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>> CatIndicesAsync<T>(string index, Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatIndicesQueryString());
+				var qs = queryString(new CatIndicesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1866,14 +1866,14 @@ public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(string index, Func<CatI
 		///<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> CatIndices(string index, Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatIndicesQueryString());
+				var qs = queryString(new CatIndicesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1896,14 +1896,14 @@ public ElasticsearchResponse<DynamicDictionary> CatIndices(string index, Func<Ca
 		///<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>> CatIndicesAsync(string index, Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatIndicesQueryString());
+				var qs = queryString(new CatIndicesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1924,13 +1924,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(string ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> CatMaster<T>(Func<CatMasterQueryString, CatMasterQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatMaster<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/master";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatMasterQueryString());
+				var qs = queryString(new CatMasterRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1952,13 +1952,13 @@ public ElasticsearchResponse<T> CatMaster<T>(Func<CatMasterQueryString, CatMaste
 		///<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>> CatMasterAsync<T>(Func<CatMasterQueryString, CatMasterQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatMasterAsync<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/master";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatMasterQueryString());
+				var qs = queryString(new CatMasterRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -1981,13 +1981,13 @@ public Task<ElasticsearchResponse<T>> CatMasterAsync<T>(Func<CatMasterQueryStrin
 		///<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> CatMaster(Func<CatMasterQueryString, CatMasterQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null)
 		{
 			var url = "_cat/master";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatMasterQueryString());
+				var qs = queryString(new CatMasterRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2009,13 +2009,13 @@ public ElasticsearchResponse<DynamicDictionary> CatMaster(Func<CatMasterQueryStr
 		///<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>> CatMasterAsync(Func<CatMasterQueryString, CatMasterQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null)
 		{
 			var url = "_cat/master";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatMasterQueryString());
+				var qs = queryString(new CatMasterRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2036,13 +2036,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatMasterAsync(Func<CatMas
 		///<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> CatNodes<T>(Func<CatNodesQueryString, CatNodesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatNodes<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/nodes";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatNodesQueryString());
+				var qs = queryString(new CatNodesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2064,13 +2064,13 @@ public ElasticsearchResponse<T> CatNodes<T>(Func<CatNodesQueryString, CatNodesQu
 		///<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>> CatNodesAsync<T>(Func<CatNodesQueryString, CatNodesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatNodesAsync<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/nodes";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatNodesQueryString());
+				var qs = queryString(new CatNodesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2093,13 +2093,13 @@ public Task<ElasticsearchResponse<T>> CatNodesAsync<T>(Func<CatNodesQueryString,
 		///<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> CatNodes(Func<CatNodesQueryString, CatNodesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null)
 		{
 			var url = "_cat/nodes";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatNodesQueryString());
+				var qs = queryString(new CatNodesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2121,13 +2121,13 @@ public ElasticsearchResponse<DynamicDictionary> CatNodes(Func<CatNodesQueryStrin
 		///<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>> CatNodesAsync(Func<CatNodesQueryString, CatNodesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null)
 		{
 			var url = "_cat/nodes";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatNodesQueryString());
+				var qs = queryString(new CatNodesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2148,13 +2148,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatNodesAsync(Func<CatNode
 		///<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> CatPendingTasks<T>(Func<CatPendingTasksQueryString, CatPendingTasksQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatPendingTasks<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/pending_tasks";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatPendingTasksQueryString());
+				var qs = queryString(new CatPendingTasksRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2176,13 +2176,13 @@ public ElasticsearchResponse<T> CatPendingTasks<T>(Func<CatPendingTasksQueryStri
 		///<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>> CatPendingTasksAsync<T>(Func<CatPendingTasksQueryString, CatPendingTasksQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatPendingTasksAsync<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/pending_tasks";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatPendingTasksQueryString());
+				var qs = queryString(new CatPendingTasksRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2205,13 +2205,13 @@ public Task<ElasticsearchResponse<T>> CatPendingTasksAsync<T>(Func<CatPendingTas
 		///<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> CatPendingTasks(Func<CatPendingTasksQueryString, CatPendingTasksQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null)
 		{
 			var url = "_cat/pending_tasks";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatPendingTasksQueryString());
+				var qs = queryString(new CatPendingTasksRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2233,13 +2233,13 @@ public ElasticsearchResponse<DynamicDictionary> CatPendingTasks(Func<CatPendingT
 		///<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>> CatPendingTasksAsync(Func<CatPendingTasksQueryString, CatPendingTasksQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null)
 		{
 			var url = "_cat/pending_tasks";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatPendingTasksQueryString());
+				var qs = queryString(new CatPendingTasksRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2260,13 +2260,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatPendingTasksAsync(Func<
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> CatRecovery<T>(Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatRecovery<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/recovery";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatRecoveryQueryString());
+				var qs = queryString(new CatRecoveryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2288,13 +2288,13 @@ public ElasticsearchResponse<T> CatRecovery<T>(Func<CatRecoveryQueryString, CatR
 		///<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>> CatRecoveryAsync<T>(Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/recovery";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatRecoveryQueryString());
+				var qs = queryString(new CatRecoveryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2317,13 +2317,13 @@ public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(Func<CatRecoveryQueryS
 		///<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> CatRecovery(Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null)
 		{
 			var url = "_cat/recovery";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatRecoveryQueryString());
+				var qs = queryString(new CatRecoveryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2345,13 +2345,13 @@ public ElasticsearchResponse<DynamicDictionary> CatRecovery(Func<CatRecoveryQuer
 		///<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>> CatRecoveryAsync(Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null)
 		{
 			var url = "_cat/recovery";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatRecoveryQueryString());
+				var qs = queryString(new CatRecoveryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2373,14 +2373,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(Func<CatR
 		///<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> CatRecovery<T>(string index, Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatRecovery<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatRecoveryQueryString());
+				var qs = queryString(new CatRecoveryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2403,14 +2403,14 @@ public ElasticsearchResponse<T> CatRecovery<T>(string index, Func<CatRecoveryQue
 		///<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>> CatRecoveryAsync<T>(string index, Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatRecoveryQueryString());
+				var qs = queryString(new CatRecoveryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2434,14 +2434,14 @@ public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(string index, Func<Cat
 		///<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> CatRecovery(string index, Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatRecoveryQueryString());
+				var qs = queryString(new CatRecoveryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2464,14 +2464,14 @@ public ElasticsearchResponse<DynamicDictionary> CatRecovery(string index, Func<C
 		///<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>> CatRecoveryAsync(string index, Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatRecoveryQueryString());
+				var qs = queryString(new CatRecoveryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2492,13 +2492,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(string in
 		///<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> CatShards<T>(Func<CatShardsQueryString, CatShardsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatShards<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/shards";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatShardsQueryString());
+				var qs = queryString(new CatShardsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2520,13 +2520,13 @@ public ElasticsearchResponse<T> CatShards<T>(Func<CatShardsQueryString, CatShard
 		///<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>> CatShardsAsync<T>(Func<CatShardsQueryString, CatShardsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/shards";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatShardsQueryString());
+				var qs = queryString(new CatShardsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2549,13 +2549,13 @@ public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(Func<CatShardsQueryStrin
 		///<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> CatShards(Func<CatShardsQueryString, CatShardsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null)
 		{
 			var url = "_cat/shards";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatShardsQueryString());
+				var qs = queryString(new CatShardsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2577,13 +2577,13 @@ public ElasticsearchResponse<DynamicDictionary> CatShards(Func<CatShardsQueryStr
 		///<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>> CatShardsAsync(Func<CatShardsQueryString, CatShardsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null)
 		{
 			var url = "_cat/shards";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatShardsQueryString());
+				var qs = queryString(new CatShardsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2605,14 +2605,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(Func<CatSha
 		///<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> CatShards<T>(string index, Func<CatShardsQueryString, CatShardsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatShards<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatShardsQueryString());
+				var qs = queryString(new CatShardsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2635,14 +2635,14 @@ public ElasticsearchResponse<T> CatShards<T>(string index, Func<CatShardsQuerySt
 		///<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>> CatShardsAsync<T>(string index, Func<CatShardsQueryString, CatShardsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatShardsQueryString());
+				var qs = queryString(new CatShardsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2666,14 +2666,14 @@ public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(string index, Func<CatSh
 		///<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> CatShards(string index, Func<CatShardsQueryString, CatShardsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatShardsQueryString());
+				var qs = queryString(new CatShardsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2696,14 +2696,14 @@ public ElasticsearchResponse<DynamicDictionary> CatShards(string index, Func<Cat
 		///<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>> CatShardsAsync(string index, Func<CatShardsQueryString, CatShardsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatShardsQueryString());
+				var qs = queryString(new CatShardsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2724,13 +2724,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(string inde
 		///<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> CatThreadPool<T>(Func<CatThreadPoolQueryString, CatThreadPoolQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatThreadPool<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/thread_pool";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatThreadPoolQueryString());
+				var qs = queryString(new CatThreadPoolRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2752,13 +2752,13 @@ public ElasticsearchResponse<T> CatThreadPool<T>(Func<CatThreadPoolQueryString,
 		///<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>> CatThreadPoolAsync<T>(Func<CatThreadPoolQueryString, CatThreadPoolQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatThreadPoolAsync<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cat/thread_pool";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatThreadPoolQueryString());
+				var qs = queryString(new CatThreadPoolRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2781,13 +2781,13 @@ public Task<ElasticsearchResponse<T>> CatThreadPoolAsync<T>(Func<CatThreadPoolQu
 		///<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> CatThreadPool(Func<CatThreadPoolQueryString, CatThreadPoolQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null)
 		{
 			var url = "_cat/thread_pool";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatThreadPoolQueryString());
+				var qs = queryString(new CatThreadPoolRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2809,13 +2809,13 @@ public ElasticsearchResponse<DynamicDictionary> CatThreadPool(Func<CatThreadPool
 		///<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>> CatThreadPoolAsync(Func<CatThreadPoolQueryString, CatThreadPoolQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null)
 		{
 			var url = "_cat/thread_pool";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CatThreadPoolQueryString());
+				var qs = queryString(new CatThreadPoolRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2837,14 +2837,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatThreadPoolAsync(Func<Ca
 		///<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> ClearScroll<T>(string scroll_id, Func<ClearScrollQueryString, ClearScrollQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClearScroll<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearScrollQueryString());
+				var qs = queryString(new ClearScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2867,14 +2867,14 @@ public ElasticsearchResponse<T> ClearScroll<T>(string scroll_id, Func<ClearScrol
 		///<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>> ClearScrollAsync<T>(string scroll_id, Func<ClearScrollQueryString, ClearScrollQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClearScrollAsync<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearScrollQueryString());
+				var qs = queryString(new ClearScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2898,14 +2898,14 @@ public Task<ElasticsearchResponse<T>> ClearScrollAsync<T>(string scroll_id, Func
 		///<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> ClearScroll(string scroll_id, Func<ClearScrollQueryString, ClearScrollQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClearScroll(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearScrollQueryString());
+				var qs = queryString(new ClearScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2928,14 +2928,14 @@ public ElasticsearchResponse<DynamicDictionary> ClearScroll(string scroll_id, Fu
 		///<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>> ClearScrollAsync(string scroll_id, Func<ClearScrollQueryString, ClearScrollQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClearScrollAsync(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearScrollQueryString());
+				var qs = queryString(new ClearScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2956,13 +2956,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClearScrollAsync(string sc
 		///<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> ClusterGetSettings<T>(Func<ClusterGetSettingsQueryString, ClusterGetSettingsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterGetSettings<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/settings";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterGetSettingsQueryString());
+				var qs = queryString(new ClusterGetSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -2984,13 +2984,13 @@ public ElasticsearchResponse<T> ClusterGetSettings<T>(Func<ClusterGetSettingsQue
 		///<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>> ClusterGetSettingsAsync<T>(Func<ClusterGetSettingsQueryString, ClusterGetSettingsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterGetSettingsAsync<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/settings";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterGetSettingsQueryString());
+				var qs = queryString(new ClusterGetSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3013,13 +3013,13 @@ public Task<ElasticsearchResponse<T>> ClusterGetSettingsAsync<T>(Func<ClusterGet
 		///<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> ClusterGetSettings(Func<ClusterGetSettingsQueryString, ClusterGetSettingsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterGetSettings(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null)
 		{
 			var url = "_cluster/settings";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterGetSettingsQueryString());
+				var qs = queryString(new ClusterGetSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3041,13 +3041,13 @@ public ElasticsearchResponse<DynamicDictionary> ClusterGetSettings(Func<ClusterG
 		///<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>> ClusterGetSettingsAsync(Func<ClusterGetSettingsQueryString, ClusterGetSettingsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterGetSettingsAsync(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null)
 		{
 			var url = "_cluster/settings";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterGetSettingsQueryString());
+				var qs = queryString(new ClusterGetSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3068,13 +3068,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterGetSettingsAsync(Fu
 		///<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> ClusterHealth<T>(Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterHealth<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/health";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterHealthQueryString());
+				var qs = queryString(new ClusterHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3096,13 +3096,13 @@ public ElasticsearchResponse<T> ClusterHealth<T>(Func<ClusterHealthQueryString,
 		///<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>> ClusterHealthAsync<T>(Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/health";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterHealthQueryString());
+				var qs = queryString(new ClusterHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3125,13 +3125,13 @@ public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(Func<ClusterHealthQu
 		///<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> ClusterHealth(Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterHealth(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null)
 		{
 			var url = "_cluster/health";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterHealthQueryString());
+				var qs = queryString(new ClusterHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3153,13 +3153,13 @@ public ElasticsearchResponse<DynamicDictionary> ClusterHealth(Func<ClusterHealth
 		///<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>> ClusterHealthAsync(Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null)
 		{
 			var url = "_cluster/health";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterHealthQueryString());
+				var qs = queryString(new ClusterHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3181,14 +3181,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(Func<Cl
 		///<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> ClusterHealth<T>(string index, Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterHealth<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/health/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterHealthQueryString());
+				var qs = queryString(new ClusterHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3211,14 +3211,14 @@ public ElasticsearchResponse<T> ClusterHealth<T>(string index, Func<ClusterHealt
 		///<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>> ClusterHealthAsync<T>(string index, Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/health/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterHealthQueryString());
+				var qs = queryString(new ClusterHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3242,14 +3242,14 @@ public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(string index, Func<C
 		///<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> ClusterHealth(string index, Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterHealth(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/health/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterHealthQueryString());
+				var qs = queryString(new ClusterHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3272,14 +3272,14 @@ public ElasticsearchResponse<DynamicDictionary> ClusterHealth(string index, Func
 		///<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>> ClusterHealthAsync(string index, Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/health/{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterHealthQueryString());
+				var qs = queryString(new ClusterHealthRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3300,13 +3300,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(string
 		///<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> ClusterPendingTasks<T>(Func<ClusterPendingTasksQueryString, ClusterPendingTasksQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterPendingTasks<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/pending_tasks";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterPendingTasksQueryString());
+				var qs = queryString(new ClusterPendingTasksRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3328,13 +3328,13 @@ public ElasticsearchResponse<T> ClusterPendingTasks<T>(Func<ClusterPendingTasksQ
 		///<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>> ClusterPendingTasksAsync<T>(Func<ClusterPendingTasksQueryString, ClusterPendingTasksQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterPendingTasksAsync<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/pending_tasks";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterPendingTasksQueryString());
+				var qs = queryString(new ClusterPendingTasksRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3357,13 +3357,13 @@ public Task<ElasticsearchResponse<T>> ClusterPendingTasksAsync<T>(Func<ClusterPe
 		///<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> ClusterPendingTasks(Func<ClusterPendingTasksQueryString, ClusterPendingTasksQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterPendingTasks(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null)
 		{
 			var url = "_cluster/pending_tasks";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterPendingTasksQueryString());
+				var qs = queryString(new ClusterPendingTasksRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3385,13 +3385,13 @@ public ElasticsearchResponse<DynamicDictionary> ClusterPendingTasks(Func<Cluster
 		///<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>> ClusterPendingTasksAsync(Func<ClusterPendingTasksQueryString, ClusterPendingTasksQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPendingTasksAsync(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null)
 		{
 			var url = "_cluster/pending_tasks";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterPendingTasksQueryString());
+				var qs = queryString(new ClusterPendingTasksRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3413,13 +3413,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPendingTasksAsync(F
 		///<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> ClusterPutSettings<T>(object body, Func<ClusterPutSettingsQueryString, ClusterPutSettingsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterPutSettings<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/settings".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterPutSettingsQueryString());
+				var qs = queryString(new ClusterPutSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3442,13 +3442,13 @@ public ElasticsearchResponse<T> ClusterPutSettings<T>(object body, Func<ClusterP
 		///<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>> ClusterPutSettingsAsync<T>(object body, Func<ClusterPutSettingsQueryString, ClusterPutSettingsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterPutSettingsAsync<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/settings".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterPutSettingsQueryString());
+				var qs = queryString(new ClusterPutSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3472,13 +3472,13 @@ public Task<ElasticsearchResponse<T>> ClusterPutSettingsAsync<T>(object body, Fu
 		///<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> ClusterPutSettings(object body, Func<ClusterPutSettingsQueryString, ClusterPutSettingsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterPutSettings(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null)
 		{
 			var url = "_cluster/settings".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterPutSettingsQueryString());
+				var qs = queryString(new ClusterPutSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3501,13 +3501,13 @@ public ElasticsearchResponse<DynamicDictionary> ClusterPutSettings(object body,
 		///<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>> ClusterPutSettingsAsync(object body, Func<ClusterPutSettingsQueryString, ClusterPutSettingsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPutSettingsAsync(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null)
 		{
 			var url = "_cluster/settings".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterPutSettingsQueryString());
+				var qs = queryString(new ClusterPutSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3529,13 +3529,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPutSettingsAsync(ob
 		///<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> ClusterReroute<T>(object body, Func<ClusterRerouteQueryString, ClusterRerouteQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterReroute<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/reroute".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterRerouteQueryString());
+				var qs = queryString(new ClusterRerouteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3558,13 +3558,13 @@ public ElasticsearchResponse<T> ClusterReroute<T>(object body, Func<ClusterRerou
 		///<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>> ClusterRerouteAsync<T>(object body, Func<ClusterRerouteQueryString, ClusterRerouteQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterRerouteAsync<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/reroute".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterRerouteQueryString());
+				var qs = queryString(new ClusterRerouteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3588,13 +3588,13 @@ public Task<ElasticsearchResponse<T>> ClusterRerouteAsync<T>(object body, Func<C
 		///<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> ClusterReroute(object body, Func<ClusterRerouteQueryString, ClusterRerouteQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterReroute(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null)
 		{
 			var url = "_cluster/reroute".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterRerouteQueryString());
+				var qs = queryString(new ClusterRerouteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3617,13 +3617,13 @@ public ElasticsearchResponse<DynamicDictionary> ClusterReroute(object body, Func
 		///<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>> ClusterRerouteAsync(object body, Func<ClusterRerouteQueryString, ClusterRerouteQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterRerouteAsync(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null)
 		{
 			var url = "_cluster/reroute".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterRerouteQueryString());
+				var qs = queryString(new ClusterRerouteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3644,13 +3644,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterRerouteAsync(object
 		///<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> ClusterState<T>(Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterState<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/state";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3672,13 +3672,13 @@ public ElasticsearchResponse<T> ClusterState<T>(Func<ClusterStateQueryString, Cl
 		///<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>> ClusterStateAsync<T>(Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/state";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3701,13 +3701,13 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(Func<ClusterStateQuer
 		///<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> ClusterState(Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterState(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
 		{
 			var url = "_cluster/state";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3729,13 +3729,13 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(Func<ClusterStateQu
 		///<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>> ClusterStateAsync(Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
 		{
 			var url = "_cluster/state";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3757,14 +3757,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(Func<Clu
 		///<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> ClusterState<T>(string metric, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterState<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_cluster/state/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3787,14 +3787,14 @@ public ElasticsearchResponse<T> ClusterState<T>(string metric, Func<ClusterState
 		///<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>> ClusterStateAsync<T>(string metric, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_cluster/state/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3818,14 +3818,14 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, Func<C
 		///<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> ClusterState(string metric, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_cluster/state/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3848,14 +3848,14 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, Func
 		///<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>> ClusterStateAsync(string metric, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_cluster/state/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3878,7 +3878,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string m
 		///<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> ClusterState<T>(string metric, string index, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterState<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index.ThrowIfNullOrEmpty("index");
@@ -3886,7 +3886,7 @@ public ElasticsearchResponse<T> ClusterState<T>(string metric, string index, Fun
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3910,7 +3910,7 @@ public ElasticsearchResponse<T> ClusterState<T>(string metric, string index, Fun
 		///<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>> ClusterStateAsync<T>(string metric, string index, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index.ThrowIfNullOrEmpty("index");
@@ -3918,7 +3918,7 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3943,7 +3943,7 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, string index, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index.ThrowIfNullOrEmpty("index");
@@ -3951,7 +3951,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -3975,7 +3975,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, stri
 		///<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>> ClusterStateAsync(string metric, string index, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index.ThrowIfNullOrEmpty("index");
@@ -3983,7 +3983,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string m
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStateQueryString());
+				var qs = queryString(new ClusterStateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4004,13 +4004,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string m
 		///<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> ClusterStats<T>(Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterStats<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStatsQueryString());
+				var qs = queryString(new ClusterStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4032,13 +4032,13 @@ public ElasticsearchResponse<T> ClusterStats<T>(Func<ClusterStatsQueryString, Cl
 		///<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>> ClusterStatsAsync<T>(Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStatsQueryString());
+				var qs = queryString(new ClusterStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4061,13 +4061,13 @@ public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(Func<ClusterStatsQuer
 		///<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> ClusterStats(Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterStats(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null)
 		{
 			var url = "_cluster/stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStatsQueryString());
+				var qs = queryString(new ClusterStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4089,13 +4089,13 @@ public ElasticsearchResponse<DynamicDictionary> ClusterStats(Func<ClusterStatsQu
 		///<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>> ClusterStatsAsync(Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null)
 		{
 			var url = "_cluster/stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStatsQueryString());
+				var qs = queryString(new ClusterStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4117,14 +4117,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(Func<Clu
 		///<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> ClusterStats<T>(string node_id, Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterStats<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/stats/nodes/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStatsQueryString());
+				var qs = queryString(new ClusterStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4147,14 +4147,14 @@ public ElasticsearchResponse<T> ClusterStats<T>(string node_id, Func<ClusterStat
 		///<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>> ClusterStatsAsync<T>(string node_id, Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/stats/nodes/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStatsQueryString());
+				var qs = queryString(new ClusterStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4178,14 +4178,14 @@ public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(string node_id, Func<
 		///<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> ClusterStats(string node_id, Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterStats(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/stats/nodes/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStatsQueryString());
+				var qs = queryString(new ClusterStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4208,14 +4208,14 @@ public ElasticsearchResponse<DynamicDictionary> ClusterStats(string node_id, Fun
 		///<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>> ClusterStatsAsync(string node_id, Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/stats/nodes/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClusterStatsQueryString());
+				var qs = queryString(new ClusterStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4237,13 +4237,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(string n
 		///<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> Count<T>(object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Count<T>(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_count".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4266,13 +4266,13 @@ public ElasticsearchResponse<T> Count<T>(object body, Func<CountQueryString, Cou
 		///<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>> CountAsync<T>(object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountAsync<T>(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_count".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4296,13 +4296,13 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(object body, Func<CountQuery
 		///<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> Count(object body, Func<CountQueryString, CountQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Count(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			var url = "_count".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4325,13 +4325,13 @@ public ElasticsearchResponse<DynamicDictionary> Count(object body, Func<CountQue
 		///<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>> CountAsync(object body, Func<CountQueryString, CountQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			var url = "_count".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4354,14 +4354,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(object body, Fu
 		///<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> Count<T>(string index, object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Count<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4385,14 +4385,14 @@ public ElasticsearchResponse<T> Count<T>(string index, object body, Func<CountQu
 		///<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>> CountAsync<T>(string index, object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4417,14 +4417,14 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, object body, F
 		///<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> Count(string index, object body, Func<CountQueryString, CountQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Count(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4448,14 +4448,14 @@ public ElasticsearchResponse<DynamicDictionary> Count(string index, object body,
 		///<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>> CountAsync(string index, object body, Func<CountQueryString, CountQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4479,7 +4479,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, o
 		///<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> Count<T>(string index, string type, object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Count<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -4487,7 +4487,7 @@ public ElasticsearchResponse<T> Count<T>(string index, string type, object body,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4512,7 +4512,7 @@ public ElasticsearchResponse<T> Count<T>(string index, string type, object body,
 		///<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>> CountAsync<T>(string index, string type, object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -4520,7 +4520,7 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, string type, o
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4546,7 +4546,7 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, string type, o
 		///<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> Count(string index, string type, object body, Func<CountQueryString, CountQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Count(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -4554,7 +4554,7 @@ public ElasticsearchResponse<DynamicDictionary> Count(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4579,7 +4579,7 @@ public ElasticsearchResponse<DynamicDictionary> Count(string index, string type,
 		///<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>> CountAsync(string index, string type, object body, Func<CountQueryString, CountQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -4587,7 +4587,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4608,13 +4608,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, s
 		///<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> CountGet<T>(Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountGet<T>(Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_count";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4636,13 +4636,13 @@ public ElasticsearchResponse<T> CountGet<T>(Func<CountQueryString, CountQueryStr
 		///<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>> CountGetAsync<T>(Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountGetAsync<T>(Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_count";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4665,13 +4665,13 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(Func<CountQueryString, Co
 		///<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> CountGet(Func<CountQueryString, CountQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountGet(Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			var url = "_count";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4693,13 +4693,13 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(Func<CountQueryString,
 		///<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>> CountGetAsync(Func<CountQueryString, CountQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			var url = "_count";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4721,14 +4721,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(Func<CountQu
 		///<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> CountGet<T>(string index, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountGet<T>(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4751,14 +4751,14 @@ public ElasticsearchResponse<T> CountGet<T>(string index, Func<CountQueryString,
 		///<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>> CountGetAsync<T>(string index, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4782,14 +4782,14 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, Func<CountQ
 		///<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> CountGet(string index, Func<CountQueryString, CountQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountGet(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4812,14 +4812,14 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(string index, Func<Coun
 		///<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>> CountGetAsync(string index, Func<CountQueryString, CountQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4842,7 +4842,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index
 		///<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> CountGet<T>(string index, string type, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountGet<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -4850,7 +4850,7 @@ public ElasticsearchResponse<T> CountGet<T>(string index, string type, Func<Coun
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4874,7 +4874,7 @@ public ElasticsearchResponse<T> CountGet<T>(string index, string type, Func<Coun
 		///<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>> CountGetAsync<T>(string index, string type, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -4882,7 +4882,7 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, string type
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4907,7 +4907,7 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, string type
 		///<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> CountGet(string index, string type, Func<CountQueryString, CountQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountGet(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -4915,7 +4915,7 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(string index, string ty
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4939,7 +4939,7 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(string index, string ty
 		///<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>> CountGetAsync(string index, string type, Func<CountQueryString, CountQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -4947,7 +4947,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountQueryString());
+				var qs = queryString(new CountRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -4970,7 +4970,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index
 		///<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> CountPercolateGet<T>(string index, string type, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -4978,7 +4978,7 @@ public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5002,7 +5002,7 @@ public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type,
 		///<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>> CountPercolateGetAsync<T>(string index, string type, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5010,7 +5010,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5035,7 +5035,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, st
 		///<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> CountPercolateGet(string index, string type, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5043,7 +5043,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5067,7 +5067,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index,
 		///<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>> CountPercolateGetAsync(string index, string type, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5075,7 +5075,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5099,7 +5099,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(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> CountPercolateGet<T>(string index, string type, string id, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5108,7 +5108,7 @@ public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5133,7 +5133,7 @@ public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type,
 		///<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>> CountPercolateGetAsync<T>(string index, string type, string id, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5142,7 +5142,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5168,7 +5168,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, st
 		///<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> CountPercolateGet(string index, string type, string id, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5177,7 +5177,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5202,7 +5202,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index,
 		///<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>> CountPercolateGetAsync(string index, string type, string id, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5211,7 +5211,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5235,7 +5235,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(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> CountPercolate<T>(string index, string type, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5243,7 +5243,7 @@ public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, obj
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5268,7 +5268,7 @@ public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, obj
 		///<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>> CountPercolateAsync<T>(string index, string type, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5276,7 +5276,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5302,7 +5302,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, strin
 		///<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> CountPercolate(string index, string type, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5310,7 +5310,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5335,7 +5335,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, str
 		///<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>> CountPercolateAsync(string index, string type, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5343,7 +5343,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5368,7 +5368,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string
 		///<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> CountPercolate<T>(string index, string type, string id, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5377,7 +5377,7 @@ public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5403,7 +5403,7 @@ public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, 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 Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, string id, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5412,7 +5412,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5439,7 +5439,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, strin
 		///<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> CountPercolate(string index, string type, string id, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5448,7 +5448,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5474,7 +5474,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, str
 		///<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>> CountPercolateAsync(string index, string type, string id, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5483,7 +5483,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CountPercolateQueryString());
+				var qs = queryString(new CountPercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5507,7 +5507,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string
 		///<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> Delete<T>(string index, string type, string id, Func<DeleteQueryString, DeleteQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Delete<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5516,7 +5516,7 @@ public ElasticsearchResponse<T> Delete<T>(string index, string type, string id,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteQueryString());
+				var qs = queryString(new DeleteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5541,7 +5541,7 @@ public ElasticsearchResponse<T> Delete<T>(string index, string type, string id,
 		///<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>> DeleteAsync<T>(string index, string type, string id, Func<DeleteQueryString, DeleteQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> DeleteAsync<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5550,7 +5550,7 @@ public Task<ElasticsearchResponse<T>> DeleteAsync<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteQueryString());
+				var qs = queryString(new DeleteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5576,7 +5576,7 @@ public Task<ElasticsearchResponse<T>> DeleteAsync<T>(string index, string type,
 		///<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> Delete(string index, string type, string id, Func<DeleteQueryString, DeleteQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Delete(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5585,7 +5585,7 @@ public ElasticsearchResponse<DynamicDictionary> Delete(string index, string type
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteQueryString());
+				var qs = queryString(new DeleteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5610,7 +5610,7 @@ public ElasticsearchResponse<DynamicDictionary> Delete(string index, string type
 		///<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>> DeleteAsync(string index, string type, string id, Func<DeleteQueryString, DeleteQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> DeleteAsync(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5619,7 +5619,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteAsync(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteQueryString());
+				var qs = queryString(new DeleteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5642,14 +5642,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteAsync(string index,
 		///<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> DeleteByQuery<T>(string index, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> DeleteByQuery<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteByQueryQueryString());
+				var qs = queryString(new DeleteByQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5673,14 +5673,14 @@ public ElasticsearchResponse<T> DeleteByQuery<T>(string index, object body, Func
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteByQueryQueryString());
+				var qs = queryString(new DeleteByQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5705,14 +5705,14 @@ public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, object
 		///<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> DeleteByQuery(string index, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteByQueryQueryString());
+				var qs = queryString(new DeleteByQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5736,14 +5736,14 @@ public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, obje
 		///<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>> DeleteByQueryAsync(string index, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteByQueryQueryString());
+				var qs = queryString(new DeleteByQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5767,7 +5767,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string
 		///<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> DeleteByQuery<T>(string index, string type, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> DeleteByQuery<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5775,7 +5775,7 @@ public ElasticsearchResponse<T> DeleteByQuery<T>(string index, string type, obje
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteByQueryQueryString());
+				var qs = queryString(new DeleteByQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5800,7 +5800,7 @@ public ElasticsearchResponse<T> DeleteByQuery<T>(string index, string type, obje
 		///<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>> DeleteByQueryAsync<T>(string index, string type, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5808,7 +5808,7 @@ public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteByQueryQueryString());
+				var qs = queryString(new DeleteByQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5834,7 +5834,7 @@ public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, string type, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5842,7 +5842,7 @@ public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteByQueryQueryString());
+				var qs = queryString(new DeleteByQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5867,7 +5867,7 @@ public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, stri
 		///<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>> DeleteByQueryAsync(string index, string type, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5875,7 +5875,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteByQueryQueryString());
+				var qs = queryString(new DeleteByQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5899,7 +5899,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string
 		///<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> Exists<T>(string index, string type, string id, Func<ExistsQueryString, ExistsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Exists<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5908,7 +5908,7 @@ public ElasticsearchResponse<T> Exists<T>(string index, string type, string id,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExistsQueryString());
+				var qs = queryString(new ExistsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5933,7 +5933,7 @@ public ElasticsearchResponse<T> Exists<T>(string index, string type, string id,
 		///<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>> ExistsAsync<T>(string index, string type, string id, Func<ExistsQueryString, ExistsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ExistsAsync<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5942,7 +5942,7 @@ public Task<ElasticsearchResponse<T>> ExistsAsync<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExistsQueryString());
+				var qs = queryString(new ExistsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -5968,7 +5968,7 @@ public Task<ElasticsearchResponse<T>> ExistsAsync<T>(string index, string type,
 		///<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> Exists(string index, string type, string id, Func<ExistsQueryString, ExistsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Exists(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -5977,7 +5977,7 @@ public ElasticsearchResponse<DynamicDictionary> Exists(string index, string type
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExistsQueryString());
+				var qs = queryString(new ExistsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6002,7 +6002,7 @@ public ElasticsearchResponse<DynamicDictionary> Exists(string index, string type
 		///<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>> ExistsAsync(string index, string type, string id, Func<ExistsQueryString, ExistsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ExistsAsync(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6011,7 +6011,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExistsAsync(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExistsQueryString());
+				var qs = queryString(new ExistsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6035,7 +6035,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExistsAsync(string index,
 		///<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> ExplainGet<T>(string index, string type, string id, Func<ExplainQueryString, ExplainQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ExplainGet<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6044,7 +6044,7 @@ public ElasticsearchResponse<T> ExplainGet<T>(string index, string type, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExplainQueryString());
+				var qs = queryString(new ExplainRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6069,7 +6069,7 @@ public ElasticsearchResponse<T> ExplainGet<T>(string index, string type, string
 		///<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>> ExplainGetAsync<T>(string index, string type, string id, Func<ExplainQueryString, ExplainQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ExplainGetAsync<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6078,7 +6078,7 @@ public Task<ElasticsearchResponse<T>> ExplainGetAsync<T>(string index, string ty
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExplainQueryString());
+				var qs = queryString(new ExplainRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6104,7 +6104,7 @@ public Task<ElasticsearchResponse<T>> ExplainGetAsync<T>(string index, string ty
 		///<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> ExplainGet(string index, string type, string id, Func<ExplainQueryString, ExplainQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ExplainGet(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6113,7 +6113,7 @@ public ElasticsearchResponse<DynamicDictionary> ExplainGet(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExplainQueryString());
+				var qs = queryString(new ExplainRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6138,7 +6138,7 @@ public ElasticsearchResponse<DynamicDictionary> ExplainGet(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string index, string type, string id, Func<ExplainQueryString, ExplainQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6147,7 +6147,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string ind
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExplainQueryString());
+				var qs = queryString(new ExplainRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6172,7 +6172,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> Explain<T>(string index, string type, string id, object body, Func<ExplainQueryString, ExplainQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Explain<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6181,7 +6181,7 @@ public ElasticsearchResponse<T> Explain<T>(string index, string type, string id,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExplainQueryString());
+				var qs = queryString(new ExplainRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6207,7 +6207,7 @@ public ElasticsearchResponse<T> Explain<T>(string index, string type, string id,
 		///<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>> ExplainAsync<T>(string index, string type, string id, object body, Func<ExplainQueryString, ExplainQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ExplainAsync<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6216,7 +6216,7 @@ public Task<ElasticsearchResponse<T>> ExplainAsync<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExplainQueryString());
+				var qs = queryString(new ExplainRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6243,7 +6243,7 @@ public Task<ElasticsearchResponse<T>> ExplainAsync<T>(string index, string type,
 		///<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> Explain(string index, string type, string id, object body, Func<ExplainQueryString, ExplainQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Explain(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6252,7 +6252,7 @@ public ElasticsearchResponse<DynamicDictionary> Explain(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExplainQueryString());
+				var qs = queryString(new ExplainRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6278,7 +6278,7 @@ public ElasticsearchResponse<DynamicDictionary> Explain(string index, string typ
 		///<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>> ExplainAsync(string index, string type, string id, object body, Func<ExplainQueryString, ExplainQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ExplainAsync(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6287,7 +6287,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExplainAsync(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ExplainQueryString());
+				var qs = queryString(new ExplainRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6311,7 +6311,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExplainAsync(string index,
 		///<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> Get<T>(string index, string type, string id, Func<GetQueryString, GetQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Get<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6320,7 +6320,7 @@ public ElasticsearchResponse<T> Get<T>(string index, string type, string id, Fun
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetQueryString());
+				var qs = queryString(new GetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6345,7 +6345,7 @@ public ElasticsearchResponse<T> Get<T>(string index, string type, string id, Fun
 		///<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>> GetAsync<T>(string index, string type, string id, Func<GetQueryString, GetQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> GetAsync<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6354,7 +6354,7 @@ public Task<ElasticsearchResponse<T>> GetAsync<T>(string index, string type, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetQueryString());
+				var qs = queryString(new GetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6380,7 +6380,7 @@ public Task<ElasticsearchResponse<T>> GetAsync<T>(string index, string type, str
 		///<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> Get(string index, string type, string id, Func<GetQueryString, GetQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Get(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6389,7 +6389,7 @@ public ElasticsearchResponse<DynamicDictionary> Get(string index, string type, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetQueryString());
+				var qs = queryString(new GetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6414,7 +6414,7 @@ public ElasticsearchResponse<DynamicDictionary> Get(string index, string type, s
 		///<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>> GetAsync(string index, string type, string id, Func<GetQueryString, GetQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6423,7 +6423,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetQueryString());
+				var qs = queryString(new GetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6447,7 +6447,7 @@ 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<SourceQueryString, SourceQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> GetSource<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6456,7 +6456,7 @@ public ElasticsearchResponse<T> GetSource<T>(string index, string type, string i
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SourceQueryString());
+				var qs = queryString(new SourceRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6481,7 +6481,7 @@ 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<SourceQueryString, SourceQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> GetSourceAsync<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6490,7 +6490,7 @@ public Task<ElasticsearchResponse<T>> GetSourceAsync<T>(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SourceQueryString());
+				var qs = queryString(new SourceRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6516,7 +6516,7 @@ public Task<ElasticsearchResponse<T>> GetSourceAsync<T>(string index, string typ
 		///<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> GetSource(string index, string type, string id, Func<SourceQueryString, SourceQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> GetSource(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6525,7 +6525,7 @@ public ElasticsearchResponse<DynamicDictionary> GetSource(string index, string t
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SourceQueryString());
+				var qs = queryString(new SourceRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6550,7 +6550,7 @@ public ElasticsearchResponse<DynamicDictionary> GetSource(string index, string t
 		///<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>> GetSourceAsync(string index, string type, string id, Func<SourceQueryString, SourceQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6559,7 +6559,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SourceQueryString());
+				var qs = queryString(new SourceRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6583,7 +6583,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string inde
 		///<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> Index<T>(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Index<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6591,7 +6591,7 @@ public ElasticsearchResponse<T> Index<T>(string index, string type, object body,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6616,7 +6616,7 @@ public ElasticsearchResponse<T> Index<T>(string index, string type, object body,
 		///<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>> IndexAsync<T>(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6624,7 +6624,7 @@ public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, o
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6650,7 +6650,7 @@ public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, o
 		///<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> Index(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Index(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6658,7 +6658,7 @@ public ElasticsearchResponse<DynamicDictionary> Index(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6683,7 +6683,7 @@ public ElasticsearchResponse<DynamicDictionary> Index(string index, string type,
 		///<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>> IndexAsync(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6691,7 +6691,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6716,7 +6716,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, s
 		///<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> Index<T>(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Index<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6725,7 +6725,7 @@ public ElasticsearchResponse<T> Index<T>(string index, string type, string id, o
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6751,7 +6751,7 @@ public ElasticsearchResponse<T> Index<T>(string index, string type, string id, o
 		///<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>> IndexAsync<T>(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6760,7 +6760,7 @@ public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6787,7 +6787,7 @@ public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, s
 		///<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> Index(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Index(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6796,7 +6796,7 @@ public ElasticsearchResponse<DynamicDictionary> Index(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6822,7 +6822,7 @@ public ElasticsearchResponse<DynamicDictionary> Index(string index, string type,
 		///<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>> IndexAsync(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6831,7 +6831,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6855,7 +6855,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, s
 		///<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> IndexPut<T>(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndexPut<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6863,7 +6863,7 @@ public ElasticsearchResponse<T> IndexPut<T>(string index, string type, object bo
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6888,7 +6888,7 @@ public ElasticsearchResponse<T> IndexPut<T>(string index, string type, object bo
 		///<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>> IndexPutAsync<T>(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6896,7 +6896,7 @@ public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6922,7 +6922,7 @@ public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type
 		///<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> IndexPut(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6930,7 +6930,7 @@ public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string ty
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6955,7 +6955,7 @@ public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string ty
 		///<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>> IndexPutAsync(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6963,7 +6963,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -6988,7 +6988,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index
 		///<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> IndexPut<T>(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndexPut<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -6997,7 +6997,7 @@ public ElasticsearchResponse<T> IndexPut<T>(string index, string type, string id
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7023,7 +7023,7 @@ public ElasticsearchResponse<T> IndexPut<T>(string index, string type, string id
 		///<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>> IndexPutAsync<T>(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -7032,7 +7032,7 @@ public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7059,7 +7059,7 @@ public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type
 		///<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> IndexPut(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -7068,7 +7068,7 @@ public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string ty
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7094,7 +7094,7 @@ public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string ty
 		///<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>> IndexPutAsync(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -7103,7 +7103,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexQueryString());
+				var qs = queryString(new IndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7124,13 +7124,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index
 		///<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> IndicesAnalyzeGetForAll<T>(Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesAnalyzeGetForAll<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_analyze";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7152,13 +7152,13 @@ public ElasticsearchResponse<T> IndicesAnalyzeGetForAll<T>(Func<AnalyzeQueryStri
 		///<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>> IndicesAnalyzeGetForAllAsync<T>(Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetForAllAsync<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_analyze";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7181,13 +7181,13 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetForAllAsync<T>(Func<Analy
 		///<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> IndicesAnalyzeGetForAll(Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGetForAll(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
 		{
 			var url = "_analyze";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7209,13 +7209,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGetForAll(Func<Ana
 		///<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>> IndicesAnalyzeGetForAllAsync(Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetForAllAsync(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
 		{
 			var url = "_analyze";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7237,14 +7237,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetForAllAsy
 		///<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> IndicesAnalyzeGet<T>(string index, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesAnalyzeGet<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7267,14 +7267,14 @@ public ElasticsearchResponse<T> IndicesAnalyzeGet<T>(string index, Func<AnalyzeQ
 		///<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>> IndicesAnalyzeGetAsync<T>(string index, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetAsync<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7298,14 +7298,14 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetAsync<T>(string index, Fu
 		///<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> IndicesAnalyzeGet(string index, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGet(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7328,14 +7328,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGet(string index,
 		///<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>> IndicesAnalyzeGetAsync(string index, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetAsync(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7357,13 +7357,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetAsync(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> IndicesAnalyzeForAll<T>(object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesAnalyzeForAll<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_analyze".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7386,13 +7386,13 @@ public ElasticsearchResponse<T> IndicesAnalyzeForAll<T>(object body, Func<Analyz
 		///<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>> IndicesAnalyzeForAllAsync<T>(object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesAnalyzeForAllAsync<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_analyze".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7416,13 +7416,13 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeForAllAsync<T>(object body,
 		///<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> IndicesAnalyzeForAll(object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeForAll(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
 		{
 			var url = "_analyze".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7445,13 +7445,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeForAll(object body
 		///<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>> IndicesAnalyzeForAllAsync(object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeForAllAsync(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
 		{
 			var url = "_analyze".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7474,14 +7474,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeForAllAsync(
 		///<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> IndicesAnalyze<T>(string index, object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesAnalyze<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7505,14 +7505,14 @@ public ElasticsearchResponse<T> IndicesAnalyze<T>(string index, object body, Fun
 		///<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>> IndicesAnalyzeAsync<T>(string index, object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesAnalyzeAsync<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7537,14 +7537,14 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeAsync<T>(string index, objec
 		///<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> IndicesAnalyze(string index, object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesAnalyze(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7568,14 +7568,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyze(string index, obj
 		///<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>> IndicesAnalyzeAsync(string index, object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeAsync(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AnalyzeQueryString());
+				var qs = queryString(new AnalyzeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7596,13 +7596,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeAsync(string
 		///<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> IndicesClearCacheForAll<T>(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClearCacheForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cache/clear";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7624,13 +7624,13 @@ public ElasticsearchResponse<T> IndicesClearCacheForAll<T>(Func<ClearCacheQueryS
 		///<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>> IndicesClearCacheForAllAsync<T>(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesClearCacheForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cache/clear";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7653,13 +7653,13 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheForAllAsync<T>(Func<Clear
 		///<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> IndicesClearCacheForAll(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
 		{
 			var url = "_cache/clear";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7681,13 +7681,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheForAll(Func<Cle
 		///<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>> IndicesClearCacheForAllAsync(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
 		{
 			var url = "_cache/clear";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7709,14 +7709,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheForAllAsy
 		///<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> IndicesClearCache<T>(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClearCache<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7739,14 +7739,14 @@ public ElasticsearchResponse<T> IndicesClearCache<T>(string index, Func<ClearCac
 		///<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>> IndicesClearCacheAsync<T>(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesClearCacheAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7770,14 +7770,14 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheAsync<T>(string index, Fu
 		///<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> IndicesClearCache(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClearCache(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7800,14 +7800,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCache(string index,
 		///<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>> IndicesClearCacheAsync(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7828,13 +7828,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheAsync(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> IndicesClearCacheGetForAll<T>(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClearCacheGetForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cache/clear";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7856,13 +7856,13 @@ public ElasticsearchResponse<T> IndicesClearCacheGetForAll<T>(Func<ClearCacheQue
 		///<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>> IndicesClearCacheGetForAllAsync<T>(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesClearCacheGetForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cache/clear";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7885,13 +7885,13 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheGetForAllAsync<T>(Func<Cl
 		///<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> IndicesClearCacheGetForAll(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGetForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
 		{
 			var url = "_cache/clear";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7913,13 +7913,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGetForAll(Func<
 		///<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>> IndicesClearCacheGetForAllAsync(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
 		{
 			var url = "_cache/clear";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7941,14 +7941,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetForAll
 		///<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> IndicesClearCacheGet<T>(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClearCacheGet<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -7971,14 +7971,14 @@ public ElasticsearchResponse<T> IndicesClearCacheGet<T>(string index, Func<Clear
 		///<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>> IndicesClearCacheGetAsync<T>(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesClearCacheGetAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8002,14 +8002,14 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheGetAsync<T>(string index,
 		///<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> IndicesClearCacheGet(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGet(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8032,14 +8032,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGet(string inde
 		///<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>> IndicesClearCacheGetAsync(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ClearCacheQueryString());
+				var qs = queryString(new ClearCacheRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8061,14 +8061,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetAsync(
 		///<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> IndicesClose<T>(string index, Func<CloseIndexQueryString, CloseIndexQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClose<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_close".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CloseIndexQueryString());
+				var qs = queryString(new CloseIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8091,14 +8091,14 @@ public ElasticsearchResponse<T> IndicesClose<T>(string index, Func<CloseIndexQue
 		///<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>> IndicesCloseAsync<T>(string index, Func<CloseIndexQueryString, CloseIndexQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesCloseAsync<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_close".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CloseIndexQueryString());
+				var qs = queryString(new CloseIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8122,14 +8122,14 @@ public Task<ElasticsearchResponse<T>> IndicesCloseAsync<T>(string index, Func<Cl
 		///<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> IndicesClose(string index, Func<CloseIndexQueryString, CloseIndexQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClose(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_close".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CloseIndexQueryString());
+				var qs = queryString(new CloseIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8152,14 +8152,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClose(string index, Func<
 		///<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>> IndicesCloseAsync(string index, Func<CloseIndexQueryString, CloseIndexQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCloseAsync(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_close".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CloseIndexQueryString());
+				var qs = queryString(new CloseIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8182,14 +8182,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCloseAsync(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 ElasticsearchResponse<T> IndicesCreate<T>(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesCreate<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CreateIndexQueryString());
+				var qs = queryString(new CreateIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8213,14 +8213,14 @@ public ElasticsearchResponse<T> IndicesCreate<T>(string index, object body, Func
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> IndicesCreateAsync<T>(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesCreateAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CreateIndexQueryString());
+				var qs = queryString(new CreateIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8245,14 +8245,14 @@ public Task<ElasticsearchResponse<T>> IndicesCreateAsync<T>(string index, object
 		///<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> IndicesCreate(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesCreate(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CreateIndexQueryString());
+				var qs = queryString(new CreateIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8276,14 +8276,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesCreate(string index, obje
 		///<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>> IndicesCreateAsync(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreateAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CreateIndexQueryString());
+				var qs = queryString(new CreateIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8306,14 +8306,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreateAsync(string
 		///<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> IndicesCreatePost<T>(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesCreatePost<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CreateIndexQueryString());
+				var qs = queryString(new CreateIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8337,14 +8337,14 @@ public ElasticsearchResponse<T> IndicesCreatePost<T>(string index, object body,
 		///<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>> IndicesCreatePostAsync<T>(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesCreatePostAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CreateIndexQueryString());
+				var qs = queryString(new CreateIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8369,14 +8369,14 @@ public Task<ElasticsearchResponse<T>> IndicesCreatePostAsync<T>(string index, ob
 		///<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> IndicesCreatePost(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesCreatePost(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CreateIndexQueryString());
+				var qs = queryString(new CreateIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8400,14 +8400,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesCreatePost(string index,
 		///<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>> IndicesCreatePostAsync(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreatePostAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new CreateIndexQueryString());
+				var qs = queryString(new CreateIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8429,14 +8429,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreatePostAsync(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> IndicesDelete<T>(string index, Func<DeleteIndexQueryString, DeleteIndexQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDelete<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteIndexQueryString());
+				var qs = queryString(new DeleteIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8459,14 +8459,14 @@ public ElasticsearchResponse<T> IndicesDelete<T>(string index, Func<DeleteIndexQ
 		///<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>> IndicesDeleteAsync<T>(string index, Func<DeleteIndexQueryString, DeleteIndexQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteAsync<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteIndexQueryString());
+				var qs = queryString(new DeleteIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8490,14 +8490,14 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteAsync<T>(string index, Func<D
 		///<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> IndicesDelete(string index, Func<DeleteIndexQueryString, DeleteIndexQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDelete(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteIndexQueryString());
+				var qs = queryString(new DeleteIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8520,14 +8520,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDelete(string index, Func
 		///<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>> IndicesDeleteAsync(string index, Func<DeleteIndexQueryString, DeleteIndexQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAsync(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteIndexQueryString());
+				var qs = queryString(new DeleteIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8550,7 +8550,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAsync(string
 		///<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> IndicesDeleteAlias<T>(string index, string name, Func<IndicesDeleteAliasQueryString, IndicesDeleteAliasQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDeleteAlias<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -8558,7 +8558,7 @@ public ElasticsearchResponse<T> IndicesDeleteAlias<T>(string index, string name,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesDeleteAliasQueryString());
+				var qs = queryString(new IndicesDeleteAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8582,7 +8582,7 @@ public ElasticsearchResponse<T> IndicesDeleteAlias<T>(string index, string name,
 		///<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>> IndicesDeleteAliasAsync<T>(string index, string name, Func<IndicesDeleteAliasQueryString, IndicesDeleteAliasQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteAliasAsync<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -8590,7 +8590,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteAliasAsync<T>(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesDeleteAliasQueryString());
+				var qs = queryString(new IndicesDeleteAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8615,7 +8615,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteAliasAsync<T>(string index, s
 		///<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> IndicesDeleteAlias(string index, string name, Func<IndicesDeleteAliasQueryString, IndicesDeleteAliasQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDeleteAlias(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -8623,7 +8623,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteAlias(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesDeleteAliasQueryString());
+				var qs = queryString(new IndicesDeleteAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8647,7 +8647,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteAlias(string index,
 		///<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>> IndicesDeleteAliasAsync(string index, string name, Func<IndicesDeleteAliasQueryString, IndicesDeleteAliasQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAliasAsync(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -8655,7 +8655,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAliasAsync(st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesDeleteAliasQueryString());
+				var qs = queryString(new IndicesDeleteAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8678,7 +8678,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAliasAsync(st
 		///<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> IndicesDeleteMapping<T>(string index, string type, Func<DeleteMappingQueryString, DeleteMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDeleteMapping<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -8686,7 +8686,7 @@ public ElasticsearchResponse<T> IndicesDeleteMapping<T>(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteMappingQueryString());
+				var qs = queryString(new DeleteMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8710,7 +8710,7 @@ public ElasticsearchResponse<T> IndicesDeleteMapping<T>(string index, string typ
 		///<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>> IndicesDeleteMappingAsync<T>(string index, string type, Func<DeleteMappingQueryString, DeleteMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteMappingAsync<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -8718,7 +8718,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteMappingAsync<T>(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteMappingQueryString());
+				var qs = queryString(new DeleteMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8743,7 +8743,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteMappingAsync<T>(string index,
 		///<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> IndicesDeleteMapping(string index, string type, Func<DeleteMappingQueryString, DeleteMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDeleteMapping(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -8751,7 +8751,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteMapping(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteMappingQueryString());
+				var qs = queryString(new DeleteMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8775,7 +8775,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteMapping(string inde
 		///<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>> IndicesDeleteMappingAsync(string index, string type, Func<DeleteMappingQueryString, DeleteMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteMappingAsync(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -8783,7 +8783,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteMappingAsync(
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteMappingQueryString());
+				var qs = queryString(new DeleteMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8805,14 +8805,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteMappingAsync(
 		///<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> IndicesDeleteTemplateForAll<T>(string name, Func<DeleteTemplateQueryString, DeleteTemplateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDeleteTemplateForAll<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteTemplateQueryString());
+				var qs = queryString(new DeleteTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8835,14 +8835,14 @@ public ElasticsearchResponse<T> IndicesDeleteTemplateForAll<T>(string name, Func
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> IndicesDeleteTemplateForAllAsync<T>(string name, Func<DeleteTemplateQueryString, DeleteTemplateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteTemplateForAllAsync<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteTemplateQueryString());
+				var qs = queryString(new DeleteTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8866,14 +8866,14 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteTemplateForAllAsync<T>(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> IndicesDeleteTemplateForAll(string name, Func<DeleteTemplateQueryString, DeleteTemplateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDeleteTemplateForAll(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteTemplateQueryString());
+				var qs = queryString(new DeleteTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8896,14 +8896,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteTemplateForAll(stri
 		///<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>> IndicesDeleteTemplateForAllAsync(string name, Func<DeleteTemplateQueryString, DeleteTemplateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteTemplateForAllAsync(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteTemplateQueryString());
+				var qs = queryString(new DeleteTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8926,7 +8926,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteTemplateForAl
 		///<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> IndicesDeleteWarmer<T>(string index, string name, Func<DeleteWarmerQueryString, DeleteWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDeleteWarmer<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -8934,7 +8934,7 @@ public ElasticsearchResponse<T> IndicesDeleteWarmer<T>(string index, string name
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteWarmerQueryString());
+				var qs = queryString(new DeleteWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8958,7 +8958,7 @@ public ElasticsearchResponse<T> IndicesDeleteWarmer<T>(string index, string name
 		///<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>> IndicesDeleteWarmerAsync<T>(string index, string name, Func<DeleteWarmerQueryString, DeleteWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteWarmerAsync<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -8966,7 +8966,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteWarmerAsync<T>(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteWarmerQueryString());
+				var qs = queryString(new DeleteWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -8991,7 +8991,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteWarmerAsync<T>(string index,
 		///<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> IndicesDeleteWarmer(string index, string name, Func<DeleteWarmerQueryString, DeleteWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDeleteWarmer(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -8999,7 +8999,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteWarmer(string index
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteWarmerQueryString());
+				var qs = queryString(new DeleteWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9023,7 +9023,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteWarmer(string index
 		///<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>> IndicesDeleteWarmerAsync(string index, string name, Func<DeleteWarmerQueryString, DeleteWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteWarmerAsync(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -9031,7 +9031,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteWarmerAsync(s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new DeleteWarmerQueryString());
+				var qs = queryString(new DeleteWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9053,14 +9053,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteWarmerAsync(s
 		///<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> IndicesExists<T>(string index, Func<IndexExistsQueryString, IndexExistsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExists<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexExistsQueryString());
+				var qs = queryString(new IndexExistsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9083,14 +9083,14 @@ public ElasticsearchResponse<T> IndicesExists<T>(string index, Func<IndexExistsQ
 		///<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>> IndicesExistsAsync<T>(string index, Func<IndexExistsQueryString, IndexExistsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsAsync<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexExistsQueryString());
+				var qs = queryString(new IndexExistsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9114,14 +9114,14 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAsync<T>(string index, Func<I
 		///<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> IndicesExists(string index, Func<IndexExistsQueryString, IndexExistsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExists(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexExistsQueryString());
+				var qs = queryString(new IndexExistsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9144,14 +9144,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExists(string index, Func
 		///<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>> IndicesExistsAsync(string index, Func<IndexExistsQueryString, IndexExistsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAsync(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndexExistsQueryString());
+				var qs = queryString(new IndexExistsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9173,14 +9173,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAsync(string
 		///<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> IndicesExistsAliasForAll<T>(string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsAliasForAll<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9203,14 +9203,14 @@ public ElasticsearchResponse<T> IndicesExistsAliasForAll<T>(string name, Func<In
 		///<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>> IndicesExistsAliasForAllAsync<T>(string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsAliasForAllAsync<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9234,14 +9234,14 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasForAllAsync<T>(string na
 		///<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> IndicesExistsAliasForAll(string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsAliasForAll(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9264,14 +9264,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAliasForAll(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasForAllAsync(string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasForAllAsync(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9294,7 +9294,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasForAllAs
 		///<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> IndicesExistsAlias<T>(string index, string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -9302,7 +9302,7 @@ public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, string name,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9326,7 +9326,7 @@ public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, string name,
 		///<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>> IndicesExistsAliasAsync<T>(string index, string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -9334,7 +9334,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9359,7 +9359,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, s
 		///<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> IndicesExistsAlias(string index, string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -9367,7 +9367,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9391,7 +9391,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index,
 		///<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>> IndicesExistsAliasAsync(string index, string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -9399,7 +9399,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9421,14 +9421,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(st
 		///<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> IndicesExistsAlias<T>(string index, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9451,14 +9451,14 @@ public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, Func<Indices
 		///<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>> IndicesExistsAliasAsync<T>(string index, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9482,14 +9482,14 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, F
 		///<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> IndicesExistsAlias(string index, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9512,14 +9512,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index,
 		///<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>> IndicesExistsAliasAsync(string index, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsAliasQueryString());
+				var qs = queryString(new IndicesExistsAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9541,14 +9541,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(st
 		///<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> IndicesExistsTemplateForAll<T>(string name, Func<IndicesExistsTemplateQueryString, IndicesExistsTemplateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsTemplateForAll<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsTemplateQueryString());
+				var qs = queryString(new IndicesExistsTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9571,14 +9571,14 @@ public ElasticsearchResponse<T> IndicesExistsTemplateForAll<T>(string name, Func
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> IndicesExistsTemplateForAllAsync<T>(string name, Func<IndicesExistsTemplateQueryString, IndicesExistsTemplateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsTemplateForAllAsync<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsTemplateQueryString());
+				var qs = queryString(new IndicesExistsTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9602,14 +9602,14 @@ public Task<ElasticsearchResponse<T>> IndicesExistsTemplateForAllAsync<T>(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> IndicesExistsTemplateForAll(string name, Func<IndicesExistsTemplateQueryString, IndicesExistsTemplateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsTemplateForAll(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsTemplateQueryString());
+				var qs = queryString(new IndicesExistsTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9632,14 +9632,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsTemplateForAll(stri
 		///<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>> IndicesExistsTemplateForAllAsync(string name, Func<IndicesExistsTemplateQueryString, IndicesExistsTemplateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTemplateForAllAsync(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsTemplateQueryString());
+				var qs = queryString(new IndicesExistsTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9662,7 +9662,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTemplateForAl
 		///<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> IndicesExistsType<T>(string index, string type, Func<IndicesExistsTypeQueryString, IndicesExistsTypeQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsType<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -9670,7 +9670,7 @@ public ElasticsearchResponse<T> IndicesExistsType<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsTypeQueryString());
+				var qs = queryString(new IndicesExistsTypeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9694,7 +9694,7 @@ public ElasticsearchResponse<T> IndicesExistsType<T>(string index, string type,
 		///<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>> IndicesExistsTypeAsync<T>(string index, string type, Func<IndicesExistsTypeQueryString, IndicesExistsTypeQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsTypeAsync<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -9702,7 +9702,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsTypeAsync<T>(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsTypeQueryString());
+				var qs = queryString(new IndicesExistsTypeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9727,7 +9727,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsTypeAsync<T>(string index, st
 		///<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> IndicesExistsType(string index, string type, Func<IndicesExistsTypeQueryString, IndicesExistsTypeQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsType(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -9735,7 +9735,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsType(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsTypeQueryString());
+				var qs = queryString(new IndicesExistsTypeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9759,7 +9759,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsType(string index,
 		///<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>> IndicesExistsTypeAsync(string index, string type, Func<IndicesExistsTypeQueryString, IndicesExistsTypeQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTypeAsync(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -9767,7 +9767,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTypeAsync(str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesExistsTypeQueryString());
+				var qs = queryString(new IndicesExistsTypeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9788,13 +9788,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTypeAsync(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> IndicesFlushForAll<T>(Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesFlushForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_flush";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9816,13 +9816,13 @@ public ElasticsearchResponse<T> IndicesFlushForAll<T>(Func<FlushQueryString, Flu
 		///<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>> IndicesFlushForAllAsync<T>(Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesFlushForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_flush";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9845,13 +9845,13 @@ public Task<ElasticsearchResponse<T>> IndicesFlushForAllAsync<T>(Func<FlushQuery
 		///<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> IndicesFlushForAll(Func<FlushQueryString, FlushQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesFlushForAll(Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
 		{
 			var url = "_flush";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9873,13 +9873,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlushForAll(Func<FlushQue
 		///<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>> IndicesFlushForAllAsync(Func<FlushQueryString, FlushQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
 		{
 			var url = "_flush";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9901,14 +9901,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushForAllAsync(Fu
 		///<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> IndicesFlush<T>(string index, Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesFlush<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9931,14 +9931,14 @@ public ElasticsearchResponse<T> IndicesFlush<T>(string index, Func<FlushQueryStr
 		///<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>> IndicesFlushAsync<T>(string index, Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesFlushAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9962,14 +9962,14 @@ public Task<ElasticsearchResponse<T>> IndicesFlushAsync<T>(string index, Func<Fl
 		///<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> IndicesFlush(string index, Func<FlushQueryString, FlushQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesFlush(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -9992,14 +9992,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlush(string index, Func<
 		///<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>> IndicesFlushAsync(string index, Func<FlushQueryString, FlushQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10020,13 +10020,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushAsync(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 ElasticsearchResponse<T> IndicesFlushGetForAll<T>(Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesFlushGetForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_flush";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10048,13 +10048,13 @@ public ElasticsearchResponse<T> IndicesFlushGetForAll<T>(Func<FlushQueryString,
 		///<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>> IndicesFlushGetForAllAsync<T>(Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesFlushGetForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_flush";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10077,13 +10077,13 @@ public Task<ElasticsearchResponse<T>> IndicesFlushGetForAllAsync<T>(Func<FlushQu
 		///<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> IndicesFlushGetForAll(Func<FlushQueryString, FlushQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesFlushGetForAll(Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
 		{
 			var url = "_flush";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10105,13 +10105,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlushGetForAll(Func<Flush
 		///<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>> IndicesFlushGetForAllAsync(Func<FlushQueryString, FlushQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
 		{
 			var url = "_flush";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10133,14 +10133,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetForAllAsync
 		///<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> IndicesFlushGet<T>(string index, Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesFlushGet<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10163,14 +10163,14 @@ public ElasticsearchResponse<T> IndicesFlushGet<T>(string index, Func<FlushQuery
 		///<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>> IndicesFlushGetAsync<T>(string index, Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesFlushGetAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10194,14 +10194,14 @@ public Task<ElasticsearchResponse<T>> IndicesFlushGetAsync<T>(string index, Func
 		///<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> IndicesFlushGet(string index, Func<FlushQueryString, FlushQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesFlushGet(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10224,14 +10224,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlushGet(string index, Fu
 		///<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>> IndicesFlushGetAsync(string index, Func<FlushQueryString, FlushQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new FlushQueryString());
+				var qs = queryString(new FlushRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10252,13 +10252,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_alias";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10280,13 +10280,13 @@ public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(Func<GetAliasesQueryStr
 		///<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>> IndicesGetAliasForAllAsync<T>(Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_alias";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10309,13 +10309,13 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(Func<GetAlia
 		///<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> IndicesGetAliasForAll(Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
 		{
 			var url = "_alias";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10337,13 +10337,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(Func<GetAl
 		///<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>> IndicesGetAliasForAllAsync(Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
 		{
 			var url = "_alias";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10365,14 +10365,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync
 		///<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> IndicesGetAliasForAll<T>(string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10395,14 +10395,14 @@ public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(string name, Func<GetAl
 		///<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>> IndicesGetAliasForAllAsync<T>(string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10426,14 +10426,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(string name,
 		///<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> IndicesGetAliasForAll(string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10456,14 +10456,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(string nam
 		///<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>> IndicesGetAliasForAllAsync(string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10486,7 +10486,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync
 		///<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> IndicesGetAlias<T>(string index, string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -10494,7 +10494,7 @@ public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, string name, Fu
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10518,7 +10518,7 @@ public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, string name, Fu
 		///<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>> IndicesGetAliasAsync<T>(string index, string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -10526,7 +10526,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10551,7 +10551,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, stri
 		///<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> IndicesGetAlias(string index, string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -10559,7 +10559,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10583,7 +10583,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, st
 		///<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>> IndicesGetAliasAsync(string index, string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -10591,7 +10591,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10613,14 +10613,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10643,14 +10643,14 @@ public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, Func<GetAliases
 		///<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>> IndicesGetAliasAsync<T>(string index, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10674,14 +10674,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, Func
 		///<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> IndicesGetAlias(string index, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10704,14 +10704,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, Fu
 		///<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>> IndicesGetAliasAsync(string index, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetAliasesQueryString());
+				var qs = queryString(new GetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10732,13 +10732,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_aliases";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10760,13 +10760,13 @@ public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(Func<IndicesGetAliase
 		///<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>> IndicesGetAliasesForAllAsync<T>(Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_aliases";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10789,13 +10789,13 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(Func<Indic
 		///<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> IndicesGetAliasesForAll(Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
 		{
 			var url = "_aliases";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10817,13 +10817,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(Func<Ind
 		///<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>> IndicesGetAliasesForAllAsync(Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
 		{
 			var url = "_aliases";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10845,14 +10845,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsy
 		///<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> IndicesGetAliases<T>(string index, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_aliases".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10875,14 +10875,14 @@ public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, Func<IndicesG
 		///<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>> IndicesGetAliasesAsync<T>(string index, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_aliases".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10906,14 +10906,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, Fu
 		///<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> IndicesGetAliases(string index, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_aliases".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10936,14 +10936,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index,
 		///<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>> IndicesGetAliasesAsync(string index, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_aliases".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10966,7 +10966,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(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> IndicesGetAliases<T>(string index, string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -10974,7 +10974,7 @@ public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, string name,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -10998,7 +10998,7 @@ public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, string name,
 		///<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>> IndicesGetAliasesAsync<T>(string index, string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -11006,7 +11006,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11031,7 +11031,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, st
 		///<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> IndicesGetAliases(string index, string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -11039,7 +11039,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11063,7 +11063,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index,
 		///<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>> IndicesGetAliasesAsync(string index, string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -11071,7 +11071,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11093,14 +11093,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(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> IndicesGetAliasesForAll<T>(string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_aliases/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11123,14 +11123,14 @@ public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(string name, Func<Ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_aliases/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11154,14 +11154,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(string nam
 		///<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> IndicesGetAliasesForAll(string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_aliases/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11184,14 +11184,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(string n
 		///<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>> IndicesGetAliasesForAllAsync(string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_aliases/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetAliasesQueryString());
+				var qs = queryString(new IndicesGetAliasesRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11213,14 +11213,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsy
 		///<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> IndicesGetFieldMappingForAll<T>(string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/field/{0}".F(Encoded(field));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11243,14 +11243,14 @@ public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string field, Fu
 		///<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>> IndicesGetFieldMappingForAllAsync<T>(string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/field/{0}".F(Encoded(field));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11274,14 +11274,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(strin
 		///<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> IndicesGetFieldMappingForAll(string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
 		{
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/field/{0}".F(Encoded(field));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11304,14 +11304,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(str
 		///<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>> IndicesGetFieldMappingForAllAsync(string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
 		{
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/field/{0}".F(Encoded(field));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11334,7 +11334,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForA
 		///<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> IndicesGetFieldMapping<T>(string index, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			field.ThrowIfNullOrEmpty("field");
@@ -11342,7 +11342,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string f
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11366,7 +11366,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string f
 		///<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>> IndicesGetFieldMappingAsync<T>(string index, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			field.ThrowIfNullOrEmpty("field");
@@ -11374,7 +11374,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11399,7 +11399,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string inde
 		///<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> IndicesGetFieldMapping(string index, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			field.ThrowIfNullOrEmpty("field");
@@ -11407,7 +11407,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string in
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11431,7 +11431,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string in
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			field.ThrowIfNullOrEmpty("field");
@@ -11439,7 +11439,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsyn
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11462,7 +11462,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsyn
 		///<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> IndicesGetFieldMappingForAll<T>(string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
@@ -11470,7 +11470,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string type, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11494,7 +11494,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string type, 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 Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
@@ -11502,7 +11502,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11527,7 +11527,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(strin
 		///<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> IndicesGetFieldMappingForAll(string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
@@ -11535,7 +11535,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11559,7 +11559,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(str
 		///<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>> IndicesGetFieldMappingForAllAsync(string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
@@ -11567,7 +11567,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForA
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11591,7 +11591,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForA
 		///<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> IndicesGetFieldMapping<T>(string index, string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -11600,7 +11600,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string t
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11625,7 +11625,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string 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>> IndicesGetFieldMappingAsync<T>(string index, string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -11634,7 +11634,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11660,7 +11660,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string inde
 		///<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> IndicesGetFieldMapping(string index, string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -11669,7 +11669,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string in
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11694,7 +11694,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string in
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -11703,7 +11703,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsyn
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingQueryString());
+				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11724,13 +11724,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsyn
 		///<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> IndicesGetMappingForAll<T>(Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mapping";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11752,13 +11752,13 @@ public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(Func<GetMappingQueryS
 		///<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>> IndicesGetMappingForAllAsync<T>(Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mapping";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11781,13 +11781,13 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(Func<GetMa
 		///<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> IndicesGetMappingForAll(Func<GetMappingQueryString, GetMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
 		{
 			var url = "_mapping";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11809,13 +11809,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(Func<Get
 		///<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>> IndicesGetMappingForAllAsync(Func<GetMappingQueryString, GetMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
 		{
 			var url = "_mapping";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11837,14 +11837,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsy
 		///<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> IndicesGetMapping<T>(string index, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mapping".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11867,14 +11867,14 @@ public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, Func<GetMappi
 		///<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>> IndicesGetMappingAsync<T>(string index, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mapping".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11898,14 +11898,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, Fu
 		///<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> IndicesGetMapping(string index, Func<GetMappingQueryString, GetMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mapping".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11928,14 +11928,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index,
 		///<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>> IndicesGetMappingAsync(string index, Func<GetMappingQueryString, GetMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mapping".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11957,14 +11957,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(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> IndicesGetMappingForAll<T>(string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -11987,14 +11987,14 @@ public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(string type, Func<Get
 		///<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>> IndicesGetMappingForAllAsync<T>(string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12018,14 +12018,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(string typ
 		///<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> IndicesGetMappingForAll(string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12048,14 +12048,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(string t
 		///<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>> IndicesGetMappingForAllAsync(string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12078,7 +12078,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsy
 		///<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> IndicesGetMapping<T>(string index, string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -12086,7 +12086,7 @@ public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12110,7 +12110,7 @@ public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, string type,
 		///<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>> IndicesGetMappingAsync<T>(string index, string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -12118,7 +12118,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12143,7 +12143,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, st
 		///<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> IndicesGetMapping(string index, string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -12151,7 +12151,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12175,7 +12175,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index,
 		///<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>> IndicesGetMappingAsync(string index, string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -12183,7 +12183,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetMappingQueryString());
+				var qs = queryString(new GetMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12204,13 +12204,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(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> IndicesGetSettingsForAll<T>(Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_settings";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12232,13 +12232,13 @@ public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(Func<GetIndexSetting
 		///<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>> IndicesGetSettingsForAllAsync<T>(Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_settings";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12261,13 +12261,13 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(Func<GetI
 		///<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> IndicesGetSettingsForAll(Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
 		{
 			var url = "_settings";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12289,13 +12289,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(Func<Ge
 		///<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>> IndicesGetSettingsForAllAsync(Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
 		{
 			var url = "_settings";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12317,14 +12317,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAs
 		///<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> IndicesGetSettings<T>(string index, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12347,14 +12347,14 @@ public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, Func<GetInde
 		///<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>> IndicesGetSettingsAsync<T>(string index, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12378,14 +12378,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, F
 		///<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> IndicesGetSettings(string index, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12408,14 +12408,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index,
 		///<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>> IndicesGetSettingsAsync(string index, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12438,7 +12438,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(st
 		///<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> IndicesGetSettings<T>(string index, string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -12446,7 +12446,7 @@ public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, string name,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12470,7 +12470,7 @@ public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, string name,
 		///<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>> IndicesGetSettingsAsync<T>(string index, string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -12478,7 +12478,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12503,7 +12503,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, s
 		///<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> IndicesGetSettings(string index, string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -12511,7 +12511,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12535,7 +12535,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index,
 		///<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>> IndicesGetSettingsAsync(string index, string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -12543,7 +12543,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12565,14 +12565,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(st
 		///<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> IndicesGetSettingsForAll<T>(string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_settings/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12595,14 +12595,14 @@ public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(string name, Func<Ge
 		///<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>> IndicesGetSettingsForAllAsync<T>(string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_settings/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12626,14 +12626,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(string na
 		///<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> IndicesGetSettingsForAll(string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_settings/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12656,14 +12656,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_settings/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetIndexSettingsQueryString());
+				var qs = queryString(new GetIndexSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12684,13 +12684,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAs
 		///<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> IndicesGetTemplateForAll<T>(Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_template";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetTemplateQueryString());
+				var qs = queryString(new GetTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12712,13 +12712,13 @@ public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(Func<GetTemplateQuer
 		///<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>> IndicesGetTemplateForAllAsync<T>(Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_template";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetTemplateQueryString());
+				var qs = queryString(new GetTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12741,13 +12741,13 @@ public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(Func<GetT
 		///<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> IndicesGetTemplateForAll(Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null)
 		{
 			var url = "_template";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetTemplateQueryString());
+				var qs = queryString(new GetTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12769,13 +12769,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(Func<Ge
 		///<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>> IndicesGetTemplateForAllAsync(Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null)
 		{
 			var url = "_template";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetTemplateQueryString());
+				var qs = queryString(new GetTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12797,14 +12797,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAs
 		///<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> IndicesGetTemplateForAll<T>(string name, Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetTemplateQueryString());
+				var qs = queryString(new GetTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12827,14 +12827,14 @@ public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(string name, Func<Ge
 		///<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>> IndicesGetTemplateForAllAsync<T>(string name, Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetTemplateQueryString());
+				var qs = queryString(new GetTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12858,14 +12858,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(string na
 		///<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> IndicesGetTemplateForAll(string name, Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetTemplateQueryString());
+				var qs = queryString(new GetTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12888,14 +12888,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(string name, Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetTemplateQueryString());
+				var qs = queryString(new GetTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12916,13 +12916,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAs
 		///<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> IndicesGetWarmerForAll<T>(Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_warmer";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12944,13 +12944,13 @@ public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(Func<GetWarmerQueryStr
 		///<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>> IndicesGetWarmerForAllAsync<T>(Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_warmer";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -12973,13 +12973,13 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(Func<GetWar
 		///<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> IndicesGetWarmerForAll(Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			var url = "_warmer";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13001,13 +13001,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(Func<GetW
 		///<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>> IndicesGetWarmerForAllAsync(Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			var url = "_warmer";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13029,14 +13029,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsyn
 		///<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> IndicesGetWarmer<T>(string index, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_warmer".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13059,14 +13059,14 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, Func<GetWarmer
 		///<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>> IndicesGetWarmerAsync<T>(string index, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_warmer".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13090,14 +13090,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, Fun
 		///<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> IndicesGetWarmer(string index, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_warmer".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13120,14 +13120,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, F
 		///<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>> IndicesGetWarmerAsync(string index, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_warmer".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13150,7 +13150,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 		///<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> IndicesGetWarmer<T>(string index, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -13158,7 +13158,7 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string name, F
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13182,7 +13182,7 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string name, F
 		///<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>> IndicesGetWarmerAsync<T>(string index, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -13190,7 +13190,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13215,7 +13215,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, str
 		///<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> IndicesGetWarmer(string index, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -13223,7 +13223,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13247,7 +13247,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, s
 		///<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>> IndicesGetWarmerAsync(string index, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -13255,7 +13255,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13277,14 +13277,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 		///<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> IndicesGetWarmerForAll<T>(string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13307,14 +13307,14 @@ public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(string name, Func<GetW
 		///<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>> IndicesGetWarmerForAllAsync<T>(string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13338,14 +13338,14 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(string name
 		///<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> IndicesGetWarmerForAll(string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13368,14 +13368,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(string na
 		///<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>> IndicesGetWarmerForAllAsync(string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13399,7 +13399,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsyn
 		///<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> IndicesGetWarmer<T>(string index, string type, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -13408,7 +13408,7 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string type, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13433,7 +13433,7 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string type, s
 		///<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>> IndicesGetWarmerAsync<T>(string index, string type, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -13442,7 +13442,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13468,7 +13468,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, str
 		///<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> IndicesGetWarmer(string index, string type, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -13477,7 +13477,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13502,7 +13502,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, s
 		///<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>> IndicesGetWarmerAsync(string index, string type, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -13511,7 +13511,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new GetWarmerQueryString());
+				var qs = queryString(new GetWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13533,14 +13533,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 		///<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> IndicesOpen<T>(string index, Func<OpenIndexQueryString, OpenIndexQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOpen<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_open".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OpenIndexQueryString());
+				var qs = queryString(new OpenIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13563,14 +13563,14 @@ public ElasticsearchResponse<T> IndicesOpen<T>(string index, Func<OpenIndexQuery
 		///<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>> IndicesOpenAsync<T>(string index, Func<OpenIndexQueryString, OpenIndexQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOpenAsync<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_open".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OpenIndexQueryString());
+				var qs = queryString(new OpenIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13594,14 +13594,14 @@ public Task<ElasticsearchResponse<T>> IndicesOpenAsync<T>(string index, Func<Ope
 		///<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> IndicesOpen(string index, Func<OpenIndexQueryString, OpenIndexQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOpen(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_open".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OpenIndexQueryString());
+				var qs = queryString(new OpenIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13624,14 +13624,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOpen(string index, Func<O
 		///<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>> IndicesOpenAsync(string index, Func<OpenIndexQueryString, OpenIndexQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOpenAsync(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_open".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OpenIndexQueryString());
+				var qs = queryString(new OpenIndexRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13652,13 +13652,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOpenAsync(string in
 		///<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> IndicesOptimizeForAll<T>(Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOptimizeForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_optimize";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13680,13 +13680,13 @@ public ElasticsearchResponse<T> IndicesOptimizeForAll<T>(Func<OptimizeQueryStrin
 		///<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>> IndicesOptimizeForAllAsync<T>(Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOptimizeForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_optimize";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13709,13 +13709,13 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeForAllAsync<T>(Func<Optimiz
 		///<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> IndicesOptimizeForAll(Func<OptimizeQueryString, OptimizeQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
 		{
 			var url = "_optimize";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13737,13 +13737,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeForAll(Func<Optim
 		///<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>> IndicesOptimizeForAllAsync(Func<OptimizeQueryString, OptimizeQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
 		{
 			var url = "_optimize";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13765,14 +13765,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeForAllAsync
 		///<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> IndicesOptimize<T>(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOptimize<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13795,14 +13795,14 @@ public ElasticsearchResponse<T> IndicesOptimize<T>(string index, Func<OptimizeQu
 		///<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>> IndicesOptimizeAsync<T>(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOptimizeAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13826,14 +13826,14 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeAsync<T>(string index, Func
 		///<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> IndicesOptimize(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOptimize(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13856,14 +13856,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimize(string index, Fu
 		///<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>> IndicesOptimizeAsync(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13884,13 +13884,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> IndicesOptimizeGetForAll<T>(Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOptimizeGetForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_optimize";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13912,13 +13912,13 @@ public ElasticsearchResponse<T> IndicesOptimizeGetForAll<T>(Func<OptimizeQuerySt
 		///<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>> IndicesOptimizeGetForAllAsync<T>(Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOptimizeGetForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_optimize";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13941,13 +13941,13 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeGetForAllAsync<T>(Func<Opti
 		///<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> IndicesOptimizeGetForAll(Func<OptimizeQueryString, OptimizeQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGetForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
 		{
 			var url = "_optimize";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13969,13 +13969,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGetForAll(Func<Op
 		///<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>> IndicesOptimizeGetForAllAsync(Func<OptimizeQueryString, OptimizeQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
 		{
 			var url = "_optimize";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -13997,14 +13997,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetForAllAs
 		///<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> IndicesOptimizeGet<T>(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOptimizeGet<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14027,14 +14027,14 @@ public ElasticsearchResponse<T> IndicesOptimizeGet<T>(string index, Func<Optimiz
 		///<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>> IndicesOptimizeGetAsync<T>(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOptimizeGetAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14058,14 +14058,14 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeGetAsync<T>(string index, F
 		///<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> IndicesOptimizeGet(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGet(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14088,14 +14088,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGet(string index,
 		///<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>> IndicesOptimizeGetAsync(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new OptimizeQueryString());
+				var qs = queryString(new OptimizeRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14119,7 +14119,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetAsync(st
 		///<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> IndicesPutAlias<T>(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutAlias<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -14127,7 +14127,7 @@ public ElasticsearchResponse<T> IndicesPutAlias<T>(string index, string name, ob
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14152,7 +14152,7 @@ public ElasticsearchResponse<T> IndicesPutAlias<T>(string index, string name, ob
 		///<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>> IndicesPutAliasAsync<T>(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutAliasAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -14160,7 +14160,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasAsync<T>(string index, stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14186,7 +14186,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasAsync<T>(string index, stri
 		///<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> IndicesPutAlias(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutAlias(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -14194,7 +14194,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAlias(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14219,7 +14219,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAlias(string index, st
 		///<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>> IndicesPutAliasAsync(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -14227,7 +14227,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasAsync(strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14250,14 +14250,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> IndicesPutAliasForAll<T>(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutAliasForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14281,14 +14281,14 @@ public ElasticsearchResponse<T> IndicesPutAliasForAll<T>(string name, object bod
 		///<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>> IndicesPutAliasForAllAsync<T>(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutAliasForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14313,14 +14313,14 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasForAllAsync<T>(string name,
 		///<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> IndicesPutAliasForAll(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14344,14 +14344,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasForAll(string nam
 		///<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>> IndicesPutAliasForAllAsync(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14375,7 +14375,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasForAllAsync
 		///<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> IndicesPutAliasPost<T>(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutAliasPost<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -14383,7 +14383,7 @@ public ElasticsearchResponse<T> IndicesPutAliasPost<T>(string index, string name
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14408,7 +14408,7 @@ public ElasticsearchResponse<T> IndicesPutAliasPost<T>(string index, string name
 		///<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>> IndicesPutAliasPostAsync<T>(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutAliasPostAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -14416,7 +14416,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasPostAsync<T>(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14442,7 +14442,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasPostAsync<T>(string index,
 		///<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> IndicesPutAliasPost(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPost(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -14450,7 +14450,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPost(string index
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14475,7 +14475,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPost(string index
 		///<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>> IndicesPutAliasPostAsync(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -14483,7 +14483,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostAsync(s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14506,14 +14506,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostAsync(s
 		///<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> IndicesPutAliasPostForAll<T>(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutAliasPostForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14537,14 +14537,14 @@ public ElasticsearchResponse<T> IndicesPutAliasPostForAll<T>(string name, object
 		///<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>> IndicesPutAliasPostForAllAsync<T>(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutAliasPostForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14569,14 +14569,14 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasPostForAllAsync<T>(string n
 		///<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> IndicesPutAliasPostForAll(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPostForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14600,14 +14600,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPostForAll(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostForAllAsync(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesPutAliasQueryString());
+				var qs = queryString(new IndicesPutAliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14631,7 +14631,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostForAllA
 		///<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> IndicesPutMapping<T>(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutMapping<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -14639,7 +14639,7 @@ public ElasticsearchResponse<T> IndicesPutMapping<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14664,7 +14664,7 @@ public ElasticsearchResponse<T> IndicesPutMapping<T>(string index, string type,
 		///<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>> IndicesPutMappingAsync<T>(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutMappingAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -14672,7 +14672,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingAsync<T>(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14698,7 +14698,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingAsync<T>(string index, st
 		///<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> IndicesPutMapping(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutMapping(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -14706,7 +14706,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMapping(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14731,7 +14731,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMapping(string index,
 		///<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>> IndicesPutMappingAsync(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -14739,7 +14739,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingAsync(str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14762,14 +14762,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingAsync(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> IndicesPutMappingForAll<T>(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutMappingForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14793,14 +14793,14 @@ public ElasticsearchResponse<T> IndicesPutMappingForAll<T>(string type, object b
 		///<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>> IndicesPutMappingForAllAsync<T>(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutMappingForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14825,14 +14825,14 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingForAllAsync<T>(string typ
 		///<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> IndicesPutMappingForAll(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14856,14 +14856,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingForAll(string t
 		///<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>> IndicesPutMappingForAllAsync(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14887,7 +14887,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingForAllAsy
 		///<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> IndicesPutMappingPost<T>(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutMappingPost<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -14895,7 +14895,7 @@ public ElasticsearchResponse<T> IndicesPutMappingPost<T>(string index, string ty
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14920,7 +14920,7 @@ public ElasticsearchResponse<T> IndicesPutMappingPost<T>(string index, string ty
 		///<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>> IndicesPutMappingPostAsync<T>(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutMappingPostAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -14928,7 +14928,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingPostAsync<T>(string index
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14954,7 +14954,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingPostAsync<T>(string index
 		///<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> IndicesPutMappingPost(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPost(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -14962,7 +14962,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPost(string ind
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -14987,7 +14987,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPost(string ind
 		///<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>> IndicesPutMappingPostAsync(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -14995,7 +14995,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostAsync
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15018,14 +15018,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostAsync
 		///<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> IndicesPutMappingPostForAll<T>(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutMappingPostForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15049,14 +15049,14 @@ public ElasticsearchResponse<T> IndicesPutMappingPostForAll<T>(string type, obje
 		///<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>> IndicesPutMappingPostForAllAsync<T>(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutMappingPostForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15081,14 +15081,14 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingPostForAllAsync<T>(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPostForAll(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPostForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15112,14 +15112,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPostForAll(stri
 		///<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>> IndicesPutMappingPostForAllAsync(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutMappingQueryString());
+				var qs = queryString(new PutMappingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15141,13 +15141,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostForAl
 		///<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> IndicesPutSettingsForAll<T>(object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutSettingsForAll<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_settings".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateSettingsQueryString());
+				var qs = queryString(new UpdateSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15170,13 +15170,13 @@ public ElasticsearchResponse<T> IndicesPutSettingsForAll<T>(object body, Func<Up
 		///<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>> IndicesPutSettingsForAllAsync<T>(object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutSettingsForAllAsync<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_settings".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateSettingsQueryString());
+				var qs = queryString(new UpdateSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15200,13 +15200,13 @@ public Task<ElasticsearchResponse<T>> IndicesPutSettingsForAllAsync<T>(object bo
 		///<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> IndicesPutSettingsForAll(object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutSettingsForAll(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null)
 		{
 			var url = "_settings".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateSettingsQueryString());
+				var qs = queryString(new UpdateSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15229,13 +15229,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutSettingsForAll(object
 		///<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>> IndicesPutSettingsForAllAsync(object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsForAllAsync(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null)
 		{
 			var url = "_settings".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateSettingsQueryString());
+				var qs = queryString(new UpdateSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15258,14 +15258,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsForAllAs
 		///<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> IndicesPutSettings<T>(string index, object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutSettings<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateSettingsQueryString());
+				var qs = queryString(new UpdateSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15289,14 +15289,14 @@ public ElasticsearchResponse<T> IndicesPutSettings<T>(string index, object body,
 		///<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>> IndicesPutSettingsAsync<T>(string index, object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutSettingsAsync<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateSettingsQueryString());
+				var qs = queryString(new UpdateSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15321,14 +15321,14 @@ public Task<ElasticsearchResponse<T>> IndicesPutSettingsAsync<T>(string index, o
 		///<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> IndicesPutSettings(string index, object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutSettings(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateSettingsQueryString());
+				var qs = queryString(new UpdateSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15352,14 +15352,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutSettings(string index,
 		///<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>> IndicesPutSettingsAsync(string index, object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsAsync(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateSettingsQueryString());
+				var qs = queryString(new UpdateSettingsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15382,14 +15382,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsAsync(st
 		///<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> IndicesPutTemplateForAll<T>(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutTemplateForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutTemplateQueryString());
+				var qs = queryString(new PutTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15413,14 +15413,14 @@ public ElasticsearchResponse<T> IndicesPutTemplateForAll<T>(string name, object
 		///<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>> IndicesPutTemplateForAllAsync<T>(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutTemplateForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutTemplateQueryString());
+				var qs = queryString(new PutTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15445,14 +15445,14 @@ public Task<ElasticsearchResponse<T>> IndicesPutTemplateForAllAsync<T>(string na
 		///<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> IndicesPutTemplateForAll(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplateForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutTemplateQueryString());
+				var qs = queryString(new PutTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15476,14 +15476,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplateForAll(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplateForAllAsync(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplateForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutTemplateQueryString());
+				var qs = queryString(new PutTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15506,14 +15506,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplateForAllAs
 		///<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> IndicesPutTemplatePostForAll<T>(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutTemplatePostForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutTemplateQueryString());
+				var qs = queryString(new PutTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15537,14 +15537,14 @@ public ElasticsearchResponse<T> IndicesPutTemplatePostForAll<T>(string name, obj
 		///<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>> IndicesPutTemplatePostForAllAsync<T>(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutTemplatePostForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutTemplateQueryString());
+				var qs = queryString(new PutTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15569,14 +15569,14 @@ public Task<ElasticsearchResponse<T>> IndicesPutTemplatePostForAllAsync<T>(strin
 		///<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> IndicesPutTemplatePostForAll(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplatePostForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutTemplateQueryString());
+				var qs = queryString(new PutTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15600,14 +15600,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplatePostForAll(str
 		///<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>> IndicesPutTemplatePostForAllAsync(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplatePostForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutTemplateQueryString());
+				var qs = queryString(new PutTemplateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15630,14 +15630,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplatePostForA
 		///<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> IndicesPutWarmerForAll<T>(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmerForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15661,14 +15661,14 @@ public ElasticsearchResponse<T> IndicesPutWarmerForAll<T>(string name, object bo
 		///<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>> IndicesPutWarmerForAllAsync<T>(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15693,14 +15693,14 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerForAllAsync<T>(string name
 		///<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> IndicesPutWarmerForAll(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15724,14 +15724,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerForAll(string na
 		///<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>> IndicesPutWarmerForAllAsync(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15755,7 +15755,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerForAllAsyn
 		///<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> IndicesPutWarmer<T>(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -15763,7 +15763,7 @@ public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string name, o
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15788,7 +15788,7 @@ public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string name, o
 		///<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>> IndicesPutWarmerAsync<T>(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -15796,7 +15796,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15822,7 +15822,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, str
 		///<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> IndicesPutWarmer(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -15830,7 +15830,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15855,7 +15855,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, s
 		///<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>> IndicesPutWarmerAsync(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -15863,7 +15863,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15888,7 +15888,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(stri
 		///<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> IndicesPutWarmer<T>(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -15897,7 +15897,7 @@ public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string type, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15923,7 +15923,7 @@ public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string type, s
 		///<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>> IndicesPutWarmerAsync<T>(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -15932,7 +15932,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15959,7 +15959,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, str
 		///<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> IndicesPutWarmer(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -15968,7 +15968,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -15994,7 +15994,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, s
 		///<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>> IndicesPutWarmerAsync(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -16003,7 +16003,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16026,14 +16026,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(stri
 		///<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> IndicesPutWarmerPostForAll<T>(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmerPostForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16057,14 +16057,14 @@ public ElasticsearchResponse<T> IndicesPutWarmerPostForAll<T>(string name, objec
 		///<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>> IndicesPutWarmerPostForAllAsync<T>(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16089,14 +16089,14 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostForAllAsync<T>(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPostForAll(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPostForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16120,14 +16120,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPostForAll(strin
 		///<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>> IndicesPutWarmerPostForAllAsync(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16151,7 +16151,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostForAll
 		///<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> IndicesPutWarmerPost<T>(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -16159,7 +16159,7 @@ public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string nam
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16184,7 +16184,7 @@ public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string nam
 		///<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>> IndicesPutWarmerPostAsync<T>(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -16192,7 +16192,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16218,7 +16218,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index,
 		///<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> IndicesPutWarmerPost(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -16226,7 +16226,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16251,7 +16251,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string inde
 		///<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>> IndicesPutWarmerPostAsync(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
@@ -16259,7 +16259,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16284,7 +16284,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(
 		///<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> IndicesPutWarmerPost<T>(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -16293,7 +16293,7 @@ public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16319,7 +16319,7 @@ public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string typ
 		///<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>> IndicesPutWarmerPostAsync<T>(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -16328,7 +16328,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16355,7 +16355,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index,
 		///<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> IndicesPutWarmerPost(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -16364,7 +16364,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16390,7 +16390,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string inde
 		///<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>> IndicesPutWarmerPostAsync(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -16399,7 +16399,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PutWarmerQueryString());
+				var qs = queryString(new PutWarmerRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16420,13 +16420,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(
 		///<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> IndicesRefreshForAll<T>(Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesRefreshForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_refresh";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16448,13 +16448,13 @@ public ElasticsearchResponse<T> IndicesRefreshForAll<T>(Func<RefreshQueryString,
 		///<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>> IndicesRefreshForAllAsync<T>(Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesRefreshForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_refresh";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16477,13 +16477,13 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshForAllAsync<T>(Func<RefreshQ
 		///<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> IndicesRefreshForAll(Func<RefreshQueryString, RefreshQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesRefreshForAll(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
 		{
 			var url = "_refresh";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16505,13 +16505,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefreshForAll(Func<Refres
 		///<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>> IndicesRefreshForAllAsync(Func<RefreshQueryString, RefreshQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
 		{
 			var url = "_refresh";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16533,14 +16533,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshForAllAsync(
 		///<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> IndicesRefresh<T>(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesRefresh<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16563,14 +16563,14 @@ public ElasticsearchResponse<T> IndicesRefresh<T>(string index, Func<RefreshQuer
 		///<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>> IndicesRefreshAsync<T>(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesRefreshAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16594,14 +16594,14 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshAsync<T>(string index, Func<
 		///<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> IndicesRefresh(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesRefresh(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16624,14 +16624,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefresh(string index, Fun
 		///<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>> IndicesRefreshAsync(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16652,13 +16652,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshAsync(string
 		///<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> IndicesRefreshGetForAll<T>(Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesRefreshGetForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_refresh";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16680,13 +16680,13 @@ public ElasticsearchResponse<T> IndicesRefreshGetForAll<T>(Func<RefreshQueryStri
 		///<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>> IndicesRefreshGetForAllAsync<T>(Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesRefreshGetForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_refresh";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16709,13 +16709,13 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshGetForAllAsync<T>(Func<Refre
 		///<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> IndicesRefreshGetForAll(Func<RefreshQueryString, RefreshQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGetForAll(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
 		{
 			var url = "_refresh";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16737,13 +16737,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGetForAll(Func<Ref
 		///<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>> IndicesRefreshGetForAllAsync(Func<RefreshQueryString, RefreshQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
 		{
 			var url = "_refresh";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16765,14 +16765,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetForAllAsy
 		///<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> IndicesRefreshGet<T>(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesRefreshGet<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16795,14 +16795,14 @@ public ElasticsearchResponse<T> IndicesRefreshGet<T>(string index, Func<RefreshQ
 		///<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>> IndicesRefreshGetAsync<T>(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesRefreshGetAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16826,14 +16826,14 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshGetAsync<T>(string index, Fu
 		///<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> IndicesRefreshGet(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGet(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16856,14 +16856,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGet(string index,
 		///<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>> IndicesRefreshGetAsync(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new RefreshQueryString());
+				var qs = queryString(new RefreshRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16884,13 +16884,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetAsync(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> IndicesSegmentsForAll<T>(Func<SegmentsQueryString, SegmentsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesSegmentsForAll<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_segments";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SegmentsQueryString());
+				var qs = queryString(new SegmentsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16912,13 +16912,13 @@ public ElasticsearchResponse<T> IndicesSegmentsForAll<T>(Func<SegmentsQueryStrin
 		///<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>> IndicesSegmentsForAllAsync<T>(Func<SegmentsQueryString, SegmentsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesSegmentsForAllAsync<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_segments";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SegmentsQueryString());
+				var qs = queryString(new SegmentsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16941,13 +16941,13 @@ public Task<ElasticsearchResponse<T>> IndicesSegmentsForAllAsync<T>(Func<Segment
 		///<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> IndicesSegmentsForAll(Func<SegmentsQueryString, SegmentsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesSegmentsForAll(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null)
 		{
 			var url = "_segments";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SegmentsQueryString());
+				var qs = queryString(new SegmentsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16969,13 +16969,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSegmentsForAll(Func<Segme
 		///<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>> IndicesSegmentsForAllAsync(Func<SegmentsQueryString, SegmentsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsForAllAsync(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null)
 		{
 			var url = "_segments";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SegmentsQueryString());
+				var qs = queryString(new SegmentsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -16997,14 +16997,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsForAllAsync
 		///<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> IndicesSegments<T>(string index, Func<SegmentsQueryString, SegmentsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesSegments<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_segments".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SegmentsQueryString());
+				var qs = queryString(new SegmentsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17027,14 +17027,14 @@ public ElasticsearchResponse<T> IndicesSegments<T>(string index, Func<SegmentsQu
 		///<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>> IndicesSegmentsAsync<T>(string index, Func<SegmentsQueryString, SegmentsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesSegmentsAsync<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_segments".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SegmentsQueryString());
+				var qs = queryString(new SegmentsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17058,14 +17058,14 @@ public Task<ElasticsearchResponse<T>> IndicesSegmentsAsync<T>(string index, Func
 		///<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> IndicesSegments(string index, Func<SegmentsQueryString, SegmentsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesSegments(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_segments".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SegmentsQueryString());
+				var qs = queryString(new SegmentsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17088,14 +17088,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSegments(string index, Fu
 		///<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>> IndicesSegmentsAsync(string index, Func<SegmentsQueryString, SegmentsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsAsync(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_segments".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SegmentsQueryString());
+				var qs = queryString(new SegmentsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17116,13 +17116,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> IndicesSnapshotIndexForAll<T>(Func<SnapshotQueryString, SnapshotQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesSnapshotIndexForAll<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_gateway/snapshot";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotQueryString());
+				var qs = queryString(new SnapshotRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17144,13 +17144,13 @@ public ElasticsearchResponse<T> IndicesSnapshotIndexForAll<T>(Func<SnapshotQuery
 		///<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>> IndicesSnapshotIndexForAllAsync<T>(Func<SnapshotQueryString, SnapshotQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexForAllAsync<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_gateway/snapshot";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotQueryString());
+				var qs = queryString(new SnapshotRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17173,13 +17173,13 @@ public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexForAllAsync<T>(Func<Sn
 		///<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> IndicesSnapshotIndexForAll(Func<SnapshotQueryString, SnapshotQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndexForAll(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null)
 		{
 			var url = "_gateway/snapshot";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotQueryString());
+				var qs = queryString(new SnapshotRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17201,13 +17201,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndexForAll(Func<
 		///<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>> IndicesSnapshotIndexForAllAsync(Func<SnapshotQueryString, SnapshotQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexForAllAsync(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null)
 		{
 			var url = "_gateway/snapshot";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotQueryString());
+				var qs = queryString(new SnapshotRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17229,14 +17229,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexForAll
 		///<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> IndicesSnapshotIndex<T>(string index, Func<SnapshotQueryString, SnapshotQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesSnapshotIndex<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_gateway/snapshot".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotQueryString());
+				var qs = queryString(new SnapshotRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17259,14 +17259,14 @@ public ElasticsearchResponse<T> IndicesSnapshotIndex<T>(string index, Func<Snaps
 		///<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>> IndicesSnapshotIndexAsync<T>(string index, Func<SnapshotQueryString, SnapshotQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexAsync<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_gateway/snapshot".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotQueryString());
+				var qs = queryString(new SnapshotRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17290,14 +17290,14 @@ public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexAsync<T>(string index,
 		///<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> IndicesSnapshotIndex(string index, Func<SnapshotQueryString, SnapshotQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndex(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_gateway/snapshot".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotQueryString());
+				var qs = queryString(new SnapshotRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17320,14 +17320,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndex(string inde
 		///<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>> IndicesSnapshotIndexAsync(string index, Func<SnapshotQueryString, SnapshotQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexAsync(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_gateway/snapshot".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotQueryString());
+				var qs = queryString(new SnapshotRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17348,13 +17348,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexAsync(
 		///<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> IndicesStatsForAll<T>(Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStatsForAll<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17376,13 +17376,13 @@ public ElasticsearchResponse<T> IndicesStatsForAll<T>(Func<IndicesStatsQueryStri
 		///<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>> IndicesStatsForAllAsync<T>(Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17405,13 +17405,13 @@ public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(Func<IndicesSta
 		///<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> IndicesStatsForAll(Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
 		{
 			var url = "_stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17433,13 +17433,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(Func<IndicesS
 		///<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>> IndicesStatsForAllAsync(Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
 		{
 			var url = "_stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17461,14 +17461,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(Fu
 		///<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> IndicesStatsForAll<T>(string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStatsForAll<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_stats/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17491,14 +17491,14 @@ public ElasticsearchResponse<T> IndicesStatsForAll<T>(string metric, Func<Indice
 		///<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>> IndicesStatsForAllAsync<T>(string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_stats/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17522,14 +17522,14 @@ public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(string metric,
 		///<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> IndicesStatsForAll(string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_stats/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17552,14 +17552,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(string metric
 		///<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>> IndicesStatsForAllAsync(string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_stats/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17581,14 +17581,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(st
 		///<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> IndicesStats<T>(string index, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStats<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_stats".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17611,14 +17611,14 @@ public ElasticsearchResponse<T> IndicesStats<T>(string index, Func<IndicesStatsQ
 		///<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>> IndicesStatsAsync<T>(string index, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_stats".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17642,14 +17642,14 @@ public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, Func<In
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_stats".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17672,14 +17672,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, Func<
 		///<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>> IndicesStatsAsync(string index, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_stats".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17702,7 +17702,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(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 ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -17710,7 +17710,7 @@ public ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Fun
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17734,7 +17734,7 @@ public ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Fun
 		///<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>> IndicesStatsAsync<T>(string index, string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -17742,7 +17742,7 @@ public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17767,7 +17767,7 @@ public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -17775,7 +17775,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17799,7 +17799,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, strin
 		///<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>> IndicesStatsAsync(string index, string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -17807,7 +17807,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string i
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatsQueryString());
+				var qs = queryString(new IndicesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17828,13 +17828,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(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 ElasticsearchResponse<T> IndicesStatusForAll<T>(Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStatusForAll<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_status";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatusQueryString());
+				var qs = queryString(new IndicesStatusRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17856,13 +17856,13 @@ public ElasticsearchResponse<T> IndicesStatusForAll<T>(Func<IndicesStatusQuerySt
 		///<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>> IndicesStatusForAllAsync<T>(Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatusForAllAsync<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_status";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatusQueryString());
+				var qs = queryString(new IndicesStatusRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17885,13 +17885,13 @@ public Task<ElasticsearchResponse<T>> IndicesStatusForAllAsync<T>(Func<IndicesSt
 		///<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> IndicesStatusForAll(Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStatusForAll(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null)
 		{
 			var url = "_status";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatusQueryString());
+				var qs = queryString(new IndicesStatusRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17913,13 +17913,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatusForAll(Func<Indices
 		///<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>> IndicesStatusForAllAsync(Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusForAllAsync(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null)
 		{
 			var url = "_status";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatusQueryString());
+				var qs = queryString(new IndicesStatusRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17941,14 +17941,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusForAllAsync(F
 		///<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> IndicesStatus<T>(string index, Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStatus<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_status".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatusQueryString());
+				var qs = queryString(new IndicesStatusRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -17971,14 +17971,14 @@ public ElasticsearchResponse<T> IndicesStatus<T>(string index, Func<IndicesStatu
 		///<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>> IndicesStatusAsync<T>(string index, Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatusAsync<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_status".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatusQueryString());
+				var qs = queryString(new IndicesStatusRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18002,14 +18002,14 @@ public Task<ElasticsearchResponse<T>> IndicesStatusAsync<T>(string index, Func<I
 		///<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> IndicesStatus(string index, Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStatus(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_status".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatusQueryString());
+				var qs = queryString(new IndicesStatusRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18032,14 +18032,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatus(string index, Func
 		///<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>> IndicesStatusAsync(string index, Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusAsync(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_status".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new IndicesStatusQueryString());
+				var qs = queryString(new IndicesStatusRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18061,13 +18061,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusAsync(string
 		///<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> IndicesUpdateAliasesForAll<T>(object body, Func<AliasQueryString, AliasQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesUpdateAliasesForAll<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_aliases".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AliasQueryString());
+				var qs = queryString(new AliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18090,13 +18090,13 @@ public ElasticsearchResponse<T> IndicesUpdateAliasesForAll<T>(object body, Func<
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> IndicesUpdateAliasesForAllAsync<T>(object body, Func<AliasQueryString, AliasQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesUpdateAliasesForAllAsync<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_aliases".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AliasQueryString());
+				var qs = queryString(new AliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18120,13 +18120,13 @@ public Task<ElasticsearchResponse<T>> IndicesUpdateAliasesForAllAsync<T>(object
 		///<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> IndicesUpdateAliasesForAll(object body, Func<AliasQueryString, AliasQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesUpdateAliasesForAll(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null)
 		{
 			var url = "_aliases".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AliasQueryString());
+				var qs = queryString(new AliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18149,13 +18149,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesUpdateAliasesForAll(objec
 		///<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>> IndicesUpdateAliasesForAllAsync(object body, Func<AliasQueryString, AliasQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesUpdateAliasesForAllAsync(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null)
 		{
 			var url = "_aliases".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new AliasQueryString());
+				var qs = queryString(new AliasRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18176,13 +18176,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesUpdateAliasesForAll
 		///<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> IndicesValidateQueryGetForAll<T>(Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQueryGetForAll<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_validate/query";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18204,13 +18204,13 @@ public ElasticsearchResponse<T> IndicesValidateQueryGetForAll<T>(Func<ValidateQu
 		///<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>> IndicesValidateQueryGetForAllAsync<T>(Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetForAllAsync<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_validate/query";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18233,13 +18233,13 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetForAllAsync<T>(Func
 		///<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> IndicesValidateQueryGetForAll(Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGetForAll(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			var url = "_validate/query";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18261,13 +18261,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGetForAll(Fu
 		///<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>> IndicesValidateQueryGetForAllAsync(Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetForAllAsync(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			var url = "_validate/query";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18289,14 +18289,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetFor
 		///<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> IndicesValidateQueryGet<T>(string index, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18319,14 +18319,14 @@ public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, Func<Va
 		///<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>> IndicesValidateQueryGetAsync<T>(string index, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18350,14 +18350,14 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string ind
 		///<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> IndicesValidateQueryGet(string index, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18380,14 +18380,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string i
 		///<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>> IndicesValidateQueryGetAsync(string index, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18410,7 +18410,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsy
 		///<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> IndicesValidateQueryGet<T>(string index, string type, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -18418,7 +18418,7 @@ public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18442,7 +18442,7 @@ public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, string
 		///<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>> IndicesValidateQueryGetAsync<T>(string index, string type, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -18450,7 +18450,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string ind
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18475,7 +18475,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string ind
 		///<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> IndicesValidateQueryGet(string index, string type, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -18483,7 +18483,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string i
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18507,7 +18507,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string i
 		///<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>> IndicesValidateQueryGetAsync(string index, string type, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -18515,7 +18515,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsy
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18537,13 +18537,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsy
 		///<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> IndicesValidateQueryForAll<T>(object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQueryForAll<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_validate/query".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18566,13 +18566,13 @@ public ElasticsearchResponse<T> IndicesValidateQueryForAll<T>(object body, Func<
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> IndicesValidateQueryForAllAsync<T>(object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryForAllAsync<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_validate/query".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18596,13 +18596,13 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryForAllAsync<T>(object
 		///<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> IndicesValidateQueryForAll(object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryForAll(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			var url = "_validate/query".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18625,13 +18625,13 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryForAll(objec
 		///<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>> IndicesValidateQueryForAllAsync(object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryForAllAsync(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			var url = "_validate/query".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18654,14 +18654,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryForAll
 		///<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> IndicesValidateQuery<T>(string index, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18685,14 +18685,14 @@ public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, object bod
 		///<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>> IndicesValidateQueryAsync<T>(string index, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18717,14 +18717,14 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index,
 		///<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> IndicesValidateQuery(string index, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18748,14 +18748,14 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string inde
 		///<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>> IndicesValidateQueryAsync(string index, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18779,7 +18779,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(
 		///<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> IndicesValidateQuery<T>(string index, string type, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -18787,7 +18787,7 @@ public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18812,7 +18812,7 @@ public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, string typ
 		///<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>> IndicesValidateQueryAsync<T>(string index, string type, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -18820,7 +18820,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18846,7 +18846,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index,
 		///<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> IndicesValidateQuery(string index, string type, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -18854,7 +18854,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18879,7 +18879,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string inde
 		///<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>> IndicesValidateQueryAsync(string index, string type, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -18887,7 +18887,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ValidateQueryQueryString());
+				var qs = queryString(new ValidateQueryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18908,13 +18908,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(
 		///<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> Info<T>(Func<InfoQueryString, InfoQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Info<T>(Func<InfoRequestParameters, InfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new InfoQueryString());
+				var qs = queryString(new InfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18936,13 +18936,13 @@ public ElasticsearchResponse<T> Info<T>(Func<InfoQueryString, InfoQueryString> q
 		///<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>> InfoAsync<T>(Func<InfoQueryString, InfoQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> InfoAsync<T>(Func<InfoRequestParameters, InfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new InfoQueryString());
+				var qs = queryString(new InfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18965,13 +18965,13 @@ public Task<ElasticsearchResponse<T>> InfoAsync<T>(Func<InfoQueryString, InfoQue
 		///<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> Info(Func<InfoQueryString, InfoQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Info(Func<InfoRequestParameters, InfoRequestParameters> queryString = null)
 		{
 			var url = "";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new InfoQueryString());
+				var qs = queryString(new InfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -18993,13 +18993,13 @@ public ElasticsearchResponse<DynamicDictionary> Info(Func<InfoQueryString, InfoQ
 		///<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>> InfoAsync(Func<InfoQueryString, InfoQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> InfoAsync(Func<InfoRequestParameters, InfoRequestParameters> queryString = null)
 		{
 			var url = "";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new InfoQueryString());
+				var qs = queryString(new InfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19020,13 +19020,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> InfoAsync(Func<InfoQuerySt
 		///<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> MgetGet<T>(Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MgetGet<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mget";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19048,13 +19048,13 @@ public ElasticsearchResponse<T> MgetGet<T>(Func<MultiGetQueryString, MultiGetQue
 		///<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>> MgetGetAsync<T>(Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mget";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19077,13 +19077,13 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(Func<MultiGetQueryString,
 		///<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> MgetGet(Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MgetGet(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			var url = "_mget";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19105,13 +19105,13 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(Func<MultiGetQueryString
 		///<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>> MgetGetAsync(Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			var url = "_mget";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19133,14 +19133,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(Func<MultiGet
 		///<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> MgetGet<T>(string index, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MgetGet<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19163,14 +19163,14 @@ public ElasticsearchResponse<T> MgetGet<T>(string index, Func<MultiGetQueryStrin
 		///<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>> MgetGetAsync<T>(string index, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19194,14 +19194,14 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, Func<MultiGe
 		///<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> MgetGet(string index, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19224,14 +19224,14 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, Func<Multi
 		///<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>> MgetGetAsync(string index, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19254,7 +19254,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index,
 		///<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> MgetGet<T>(string index, string type, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MgetGet<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19262,7 +19262,7 @@ public ElasticsearchResponse<T> MgetGet<T>(string index, string type, Func<Multi
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19286,7 +19286,7 @@ public ElasticsearchResponse<T> MgetGet<T>(string index, string type, Func<Multi
 		///<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>> MgetGetAsync<T>(string index, string type, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19294,7 +19294,7 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19319,7 +19319,7 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, string type,
 		///<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> MgetGet(string index, string type, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19327,7 +19327,7 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19351,7 +19351,7 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, string typ
 		///<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>> MgetGetAsync(string index, string type, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19359,7 +19359,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19381,13 +19381,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index,
 		///<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> Mget<T>(object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mget<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mget".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19410,13 +19410,13 @@ public ElasticsearchResponse<T> Mget<T>(object body, Func<MultiGetQueryString, M
 		///<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>> MgetAsync<T>(object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetAsync<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mget".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19440,13 +19440,13 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(object body, Func<MultiGetQue
 		///<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> Mget(object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mget(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			var url = "_mget".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19469,13 +19469,13 @@ public ElasticsearchResponse<DynamicDictionary> Mget(object body, Func<MultiGetQ
 		///<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>> MgetAsync(object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			var url = "_mget".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19498,14 +19498,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(object body, Fun
 		///<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> Mget<T>(string index, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mget<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19529,14 +19529,14 @@ public ElasticsearchResponse<T> Mget<T>(string index, object body, Func<MultiGet
 		///<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>> MgetAsync<T>(string index, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19561,14 +19561,14 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, object body, Fu
 		///<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> Mget(string index, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mget(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19592,14 +19592,14 @@ public ElasticsearchResponse<DynamicDictionary> Mget(string index, object body,
 		///<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>> MgetAsync(string index, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19623,7 +19623,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, ob
 		///<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> Mget<T>(string index, string type, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mget<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19631,7 +19631,7 @@ public ElasticsearchResponse<T> Mget<T>(string index, string type, object body,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19656,7 +19656,7 @@ public ElasticsearchResponse<T> Mget<T>(string index, string type, object body,
 		///<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>> MgetAsync<T>(string index, string type, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19664,7 +19664,7 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, string type, ob
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19690,7 +19690,7 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, string type, ob
 		///<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> Mget(string index, string type, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mget(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19698,7 +19698,7 @@ public ElasticsearchResponse<DynamicDictionary> Mget(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19723,7 +19723,7 @@ public ElasticsearchResponse<DynamicDictionary> Mget(string index, string type,
 		///<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>> MgetAsync(string index, string type, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19731,7 +19731,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiGetQueryString());
+				var qs = queryString(new MultiGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19755,7 +19755,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, st
 		///<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> MltGet<T>(string index, string type, string id, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MltGet<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19764,7 +19764,7 @@ public ElasticsearchResponse<T> MltGet<T>(string index, string type, string id,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MoreLikeThisQueryString());
+				var qs = queryString(new MoreLikeThisRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19789,7 +19789,7 @@ public ElasticsearchResponse<T> MltGet<T>(string index, string type, string id,
 		///<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>> MltGetAsync<T>(string index, string type, string id, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MltGetAsync<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19798,7 +19798,7 @@ public Task<ElasticsearchResponse<T>> MltGetAsync<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MoreLikeThisQueryString());
+				var qs = queryString(new MoreLikeThisRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19824,7 +19824,7 @@ public Task<ElasticsearchResponse<T>> MltGetAsync<T>(string index, string type,
 		///<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> MltGet(string index, string type, string id, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MltGet(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19833,7 +19833,7 @@ public ElasticsearchResponse<DynamicDictionary> MltGet(string index, string type
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MoreLikeThisQueryString());
+				var qs = queryString(new MoreLikeThisRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19858,7 +19858,7 @@ public ElasticsearchResponse<DynamicDictionary> MltGet(string index, string type
 		///<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>> MltGetAsync(string index, string type, string id, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MltGetAsync(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19867,7 +19867,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MltGetAsync(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MoreLikeThisQueryString());
+				var qs = queryString(new MoreLikeThisRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19892,7 +19892,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MltGetAsync(string index,
 		///<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> Mlt<T>(string index, string type, string id, object body, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mlt<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19901,7 +19901,7 @@ public ElasticsearchResponse<T> Mlt<T>(string index, string type, string id, obj
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MoreLikeThisQueryString());
+				var qs = queryString(new MoreLikeThisRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19927,7 +19927,7 @@ public ElasticsearchResponse<T> Mlt<T>(string index, string type, string id, obj
 		///<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>> MltAsync<T>(string index, string type, string id, object body, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MltAsync<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19936,7 +19936,7 @@ public Task<ElasticsearchResponse<T>> MltAsync<T>(string index, string type, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MoreLikeThisQueryString());
+				var qs = queryString(new MoreLikeThisRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19963,7 +19963,7 @@ public Task<ElasticsearchResponse<T>> MltAsync<T>(string index, string type, str
 		///<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> Mlt(string index, string type, string id, object body, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mlt(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -19972,7 +19972,7 @@ public ElasticsearchResponse<DynamicDictionary> Mlt(string index, string type, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MoreLikeThisQueryString());
+				var qs = queryString(new MoreLikeThisRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -19998,7 +19998,7 @@ public ElasticsearchResponse<DynamicDictionary> Mlt(string index, string type, s
 		///<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>> MltAsync(string index, string type, string id, object body, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MltAsync(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -20007,7 +20007,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MltAsync(string index, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MoreLikeThisQueryString());
+				var qs = queryString(new MoreLikeThisRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20028,13 +20028,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MltAsync(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> MpercolateGet<T>(Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MpercolateGet<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mpercolate";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20056,13 +20056,13 @@ public ElasticsearchResponse<T> MpercolateGet<T>(Func<MpercolateQueryString, Mpe
 		///<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>> MpercolateGetAsync<T>(Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mpercolate";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20085,13 +20085,13 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(Func<MpercolateQuery
 		///<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> MpercolateGet(Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MpercolateGet(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			var url = "_mpercolate";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20113,13 +20113,13 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(Func<MpercolateQue
 		///<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>> MpercolateGetAsync(Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			var url = "_mpercolate";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20141,14 +20141,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(Func<Mp
 		///<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> MpercolateGet<T>(string index, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MpercolateGet<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20171,14 +20171,14 @@ public ElasticsearchResponse<T> MpercolateGet<T>(string index, Func<MpercolateQu
 		///<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>> MpercolateGetAsync<T>(string index, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20202,14 +20202,14 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, Func<M
 		///<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> MpercolateGet(string index, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20232,14 +20232,14 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, Func
 		///<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>> MpercolateGetAsync(string index, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20262,7 +20262,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string
 		///<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> MpercolateGet<T>(string index, string type, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MpercolateGet<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -20270,7 +20270,7 @@ public ElasticsearchResponse<T> MpercolateGet<T>(string index, string type, Func
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20294,7 +20294,7 @@ public ElasticsearchResponse<T> MpercolateGet<T>(string index, string type, Func
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string type, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -20302,7 +20302,7 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20327,7 +20327,7 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, string type, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -20335,7 +20335,7 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20359,7 +20359,7 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, stri
 		///<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>> MpercolateGetAsync(string index, string type, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -20367,7 +20367,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20389,13 +20389,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string
 		///<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> Mpercolate<T>(object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mpercolate<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mpercolate".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20418,13 +20418,13 @@ public ElasticsearchResponse<T> Mpercolate<T>(object body, Func<MpercolateQueryS
 		///<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>> MpercolateAsync<T>(object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mpercolate".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20448,13 +20448,13 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(object body, Func<Mperc
 		///<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> Mpercolate(object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mpercolate(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			var url = "_mpercolate".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20477,13 +20477,13 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(object body, Func<Mpe
 		///<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>> MpercolateAsync(object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			var url = "_mpercolate".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20506,14 +20506,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(object bod
 		///<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> Mpercolate<T>(string index, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mpercolate<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20537,14 +20537,14 @@ public ElasticsearchResponse<T> Mpercolate<T>(string index, object body, Func<Mp
 		///<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>> MpercolateAsync<T>(string index, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20569,14 +20569,14 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, object bo
 		///<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> Mpercolate(string index, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20600,14 +20600,14 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, object
 		///<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>> MpercolateAsync(string index, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20631,7 +20631,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -20639,7 +20639,7 @@ public ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20664,7 +20664,7 @@ public ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object
 		///<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>> MpercolateAsync<T>(string index, string type, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -20672,7 +20672,7 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, string ty
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20698,7 +20698,7 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, string ty
 		///<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> Mpercolate(string index, string type, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -20706,7 +20706,7 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20731,7 +20731,7 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, string type, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -20739,7 +20739,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string ind
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MpercolateQueryString());
+				var qs = queryString(new MpercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20760,13 +20760,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> MsearchGet<T>(Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MsearchGet<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_msearch";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20788,13 +20788,13 @@ public ElasticsearchResponse<T> MsearchGet<T>(Func<MultiSearchQueryString, Multi
 		///<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>> MsearchGetAsync<T>(Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_msearch";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20817,13 +20817,13 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(Func<MultiSearchQuerySt
 		///<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> MsearchGet(Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MsearchGet(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			var url = "_msearch";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20845,13 +20845,13 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(Func<MultiSearchQuery
 		///<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>> MsearchGetAsync(Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			var url = "_msearch";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20873,14 +20873,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(Func<Multi
 		///<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> MsearchGet<T>(string index, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MsearchGet<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20903,14 +20903,14 @@ public ElasticsearchResponse<T> MsearchGet<T>(string index, Func<MultiSearchQuer
 		///<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>> MsearchGetAsync<T>(string index, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20934,14 +20934,14 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, Func<Mult
 		///<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> MsearchGet(string index, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20964,14 +20964,14 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, Func<Mu
 		///<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>> MsearchGetAsync(string index, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -20994,7 +20994,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21002,7 +21002,7 @@ public ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<Mu
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21026,7 +21026,7 @@ public ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<Mu
 		///<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>> MsearchGetAsync<T>(string index, string type, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21034,7 +21034,7 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, string ty
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21059,7 +21059,7 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, string ty
 		///<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> MsearchGet(string index, string type, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21067,7 +21067,7 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21091,7 +21091,7 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, string type, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21099,7 +21099,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string ind
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21121,13 +21121,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> Msearch<T>(object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Msearch<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_msearch".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21150,13 +21150,13 @@ public ElasticsearchResponse<T> Msearch<T>(object body, Func<MultiSearchQueryStr
 		///<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>> MsearchAsync<T>(object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchAsync<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_msearch".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21180,13 +21180,13 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(object body, Func<MultiSea
 		///<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> Msearch(object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Msearch(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			var url = "_msearch".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21209,13 +21209,13 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(object body, Func<MultiS
 		///<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>> MsearchAsync(object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			var url = "_msearch".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21238,14 +21238,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(object body,
 		///<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> Msearch<T>(string index, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Msearch<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21269,14 +21269,14 @@ public ElasticsearchResponse<T> Msearch<T>(string index, object body, Func<Multi
 		///<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>> MsearchAsync<T>(string index, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21301,14 +21301,14 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, object body,
 		///<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> Msearch(string index, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Msearch(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21332,14 +21332,14 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(string index, object bod
 		///<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>> MsearchAsync(string index, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21363,7 +21363,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index,
 		///<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> Msearch<T>(string index, string type, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Msearch<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21371,7 +21371,7 @@ public ElasticsearchResponse<T> Msearch<T>(string index, string type, object bod
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21396,7 +21396,7 @@ public ElasticsearchResponse<T> Msearch<T>(string index, string type, object bod
 		///<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>> MsearchAsync<T>(string index, string type, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21404,7 +21404,7 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21430,7 +21430,7 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, string type,
 		///<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> Msearch(string index, string type, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Msearch(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21438,7 +21438,7 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21463,7 +21463,7 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(string index, string typ
 		///<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>> MsearchAsync(string index, string type, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21471,7 +21471,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MultiSearchQueryString());
+				var qs = queryString(new MultiSearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21492,13 +21492,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index,
 		///<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> MtermvectorsGet<T>(Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MtermvectorsGet<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mtermvectors";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21520,13 +21520,13 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(Func<MtermvectorsQueryString,
 		///<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>> MtermvectorsGetAsync<T>(Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mtermvectors";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21549,13 +21549,13 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(Func<MtermvectorsQ
 		///<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> MtermvectorsGet(Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			var url = "_mtermvectors";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21577,13 +21577,13 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(Func<Mtermvector
 		///<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>> MtermvectorsGetAsync(Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			var url = "_mtermvectors";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21605,14 +21605,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(Func<
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21635,14 +21635,14 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, Func<Mtermvecto
 		///<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>> MtermvectorsGetAsync<T>(string index, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21666,14 +21666,14 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, Func
 		///<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> MtermvectorsGet(string index, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21696,14 +21696,14 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, Fu
 		///<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>> MtermvectorsGetAsync(string index, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21726,7 +21726,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21734,7 +21734,7 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Fu
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21758,7 +21758,7 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Fu
 		///<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>> MtermvectorsGetAsync<T>(string index, string type, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21766,7 +21766,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21791,7 +21791,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, stri
 		///<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> MtermvectorsGet(string index, string type, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21799,7 +21799,7 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21823,7 +21823,7 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, st
 		///<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>> MtermvectorsGetAsync(string index, string type, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -21831,7 +21831,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21853,13 +21853,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> Mtermvectors<T>(object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mtermvectors<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mtermvectors".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21882,13 +21882,13 @@ public ElasticsearchResponse<T> Mtermvectors<T>(object body, Func<MtermvectorsQu
 		///<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>> MtermvectorsAsync<T>(object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_mtermvectors".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21912,13 +21912,13 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(object body, Func<Mte
 		///<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> Mtermvectors(object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mtermvectors(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			var url = "_mtermvectors".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21941,13 +21941,13 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(object body, Func<M
 		///<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>> MtermvectorsAsync(object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			var url = "_mtermvectors".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -21970,14 +21970,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(object b
 		///<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> Mtermvectors<T>(string index, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mtermvectors<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22001,14 +22001,14 @@ public ElasticsearchResponse<T> Mtermvectors<T>(string index, object body, Func<
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22033,14 +22033,14 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, object
 		///<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> Mtermvectors(string index, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22064,14 +22064,14 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, objec
 		///<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>> MtermvectorsAsync(string index, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22095,7 +22095,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(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 ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -22103,7 +22103,7 @@ public ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, objec
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22128,7 +22128,7 @@ public ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, objec
 		///<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>> MtermvectorsAsync<T>(string index, string type, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -22136,7 +22136,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22162,7 +22162,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, string type, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -22170,7 +22170,7 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22195,7 +22195,7 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, strin
 		///<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>> MtermvectorsAsync(string index, string type, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -22203,7 +22203,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string i
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new MtermvectorsQueryString());
+				var qs = queryString(new MtermvectorsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22224,13 +22224,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(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 ElasticsearchResponse<T> NodesHotThreadsForAll<T>(Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesHotThreadsForAll<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/nodes/hotthreads";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesHotThreadsQueryString());
+				var qs = queryString(new NodesHotThreadsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22252,13 +22252,13 @@ public ElasticsearchResponse<T> NodesHotThreadsForAll<T>(Func<NodesHotThreadsQue
 		///<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>> NodesHotThreadsForAllAsync<T>(Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesHotThreadsForAllAsync<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_cluster/nodes/hotthreads";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesHotThreadsQueryString());
+				var qs = queryString(new NodesHotThreadsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22281,13 +22281,13 @@ public Task<ElasticsearchResponse<T>> NodesHotThreadsForAllAsync<T>(Func<NodesHo
 		///<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> NodesHotThreadsForAll(Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesHotThreadsForAll(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null)
 		{
 			var url = "_cluster/nodes/hotthreads";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesHotThreadsQueryString());
+				var qs = queryString(new NodesHotThreadsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22309,13 +22309,13 @@ public ElasticsearchResponse<DynamicDictionary> NodesHotThreadsForAll(Func<Nodes
 		///<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>> NodesHotThreadsForAllAsync(Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsForAllAsync(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null)
 		{
 			var url = "_cluster/nodes/hotthreads";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesHotThreadsQueryString());
+				var qs = queryString(new NodesHotThreadsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22337,14 +22337,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsForAllAsync
 		///<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> NodesHotThreads<T>(string node_id, Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesHotThreads<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/hotthreads".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesHotThreadsQueryString());
+				var qs = queryString(new NodesHotThreadsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22367,14 +22367,14 @@ public ElasticsearchResponse<T> NodesHotThreads<T>(string node_id, Func<NodesHot
 		///<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>> NodesHotThreadsAsync<T>(string node_id, Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesHotThreadsAsync<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/hotthreads".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesHotThreadsQueryString());
+				var qs = queryString(new NodesHotThreadsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22398,14 +22398,14 @@ public Task<ElasticsearchResponse<T>> NodesHotThreadsAsync<T>(string node_id, Fu
 		///<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> NodesHotThreads(string node_id, Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesHotThreads(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/hotthreads".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesHotThreadsQueryString());
+				var qs = queryString(new NodesHotThreadsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22428,14 +22428,14 @@ public ElasticsearchResponse<DynamicDictionary> NodesHotThreads(string node_id,
 		///<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>> NodesHotThreadsAsync(string node_id, Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsAsync(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/hotthreads".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesHotThreadsQueryString());
+				var qs = queryString(new NodesHotThreadsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22456,13 +22456,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> NodesInfoForAll<T>(Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesInfoForAll<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_nodes";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22484,13 +22484,13 @@ public ElasticsearchResponse<T> NodesInfoForAll<T>(Func<NodesInfoQueryString, No
 		///<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>> NodesInfoForAllAsync<T>(Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_nodes";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22513,13 +22513,13 @@ public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(Func<NodesInfoQuer
 		///<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> NodesInfoForAll(Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
 		{
 			var url = "_nodes";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22541,13 +22541,13 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(Func<NodesInfoQu
 		///<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>> NodesInfoForAllAsync(Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
 		{
 			var url = "_nodes";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22569,14 +22569,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(Func<
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> NodesInfo<T>(string node_id, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesInfo<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22599,14 +22599,14 @@ public ElasticsearchResponse<T> NodesInfo<T>(string node_id, Func<NodesInfoQuery
 		///<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>> NodesInfoAsync<T>(string node_id, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22630,14 +22630,14 @@ public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, Func<Nod
 		///<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> NodesInfo(string node_id, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22660,14 +22660,14 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, Func<N
 		///<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>> NodesInfoAsync(string node_id, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22689,14 +22689,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node
 		///<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> NodesInfoForAll<T>(string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesInfoForAll<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22719,14 +22719,14 @@ public ElasticsearchResponse<T> NodesInfoForAll<T>(string metric, Func<NodesInfo
 		///<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>> NodesInfoForAllAsync<T>(string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22750,14 +22750,14 @@ public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(string metric, Fun
 		///<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> NodesInfoForAll(string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22780,14 +22780,14 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(string metric, F
 		///<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>> NodesInfoForAllAsync(string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22810,7 +22810,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -22818,7 +22818,7 @@ public ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22842,7 +22842,7 @@ public ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -22850,7 +22850,7 @@ public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string m
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22875,7 +22875,7 @@ public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string m
 		///<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> NodesInfo(string node_id, string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -22883,7 +22883,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22907,7 +22907,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -22915,7 +22915,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesInfoQueryString());
+				var qs = queryString(new NodesInfoRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22936,13 +22936,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node
 		///<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> NodesShutdownForAll<T>(Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesShutdownForAll<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_shutdown";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesShutdownQueryString());
+				var qs = queryString(new NodesShutdownRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22964,13 +22964,13 @@ public ElasticsearchResponse<T> NodesShutdownForAll<T>(Func<NodesShutdownQuerySt
 		///<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>> NodesShutdownForAllAsync<T>(Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesShutdownForAllAsync<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_shutdown";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesShutdownQueryString());
+				var qs = queryString(new NodesShutdownRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -22993,13 +22993,13 @@ public Task<ElasticsearchResponse<T>> NodesShutdownForAllAsync<T>(Func<NodesShut
 		///<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> NodesShutdownForAll(Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesShutdownForAll(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null)
 		{
 			var url = "_shutdown";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesShutdownQueryString());
+				var qs = queryString(new NodesShutdownRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23021,13 +23021,13 @@ public ElasticsearchResponse<DynamicDictionary> NodesShutdownForAll(Func<NodesSh
 		///<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>> NodesShutdownForAllAsync(Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownForAllAsync(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null)
 		{
 			var url = "_shutdown";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesShutdownQueryString());
+				var qs = queryString(new NodesShutdownRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23049,14 +23049,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownForAllAsync(F
 		///<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> NodesShutdown<T>(string node_id, Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesShutdown<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/_shutdown".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesShutdownQueryString());
+				var qs = queryString(new NodesShutdownRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23079,14 +23079,14 @@ public ElasticsearchResponse<T> NodesShutdown<T>(string node_id, Func<NodesShutd
 		///<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>> NodesShutdownAsync<T>(string node_id, Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesShutdownAsync<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/_shutdown".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesShutdownQueryString());
+				var qs = queryString(new NodesShutdownRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23110,14 +23110,14 @@ public Task<ElasticsearchResponse<T>> NodesShutdownAsync<T>(string node_id, Func
 		///<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> NodesShutdown(string node_id, Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesShutdown(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/_shutdown".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesShutdownQueryString());
+				var qs = queryString(new NodesShutdownRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23140,14 +23140,14 @@ public ElasticsearchResponse<DynamicDictionary> NodesShutdown(string node_id, Fu
 		///<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>> NodesShutdownAsync(string node_id, Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownAsync(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/_shutdown".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesShutdownQueryString());
+				var qs = queryString(new NodesShutdownRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23168,13 +23168,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownAsync(string
 		///<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> NodesStatsForAll<T>(Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStatsForAll<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_nodes/stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23196,13 +23196,13 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(Func<NodesStatsQueryString,
 		///<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>> NodesStatsForAllAsync<T>(Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_nodes/stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23225,13 +23225,13 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(Func<NodesStatsQu
 		///<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> NodesStatsForAll(Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			var url = "_nodes/stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23253,13 +23253,13 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(Func<NodesStats
 		///<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>> NodesStatsForAllAsync(Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			var url = "_nodes/stats";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23281,14 +23281,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(Func
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> NodesStats<T>(string node_id, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStats<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}/stats".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23311,14 +23311,14 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, Func<NodesStatsQue
 		///<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>> NodesStatsAsync<T>(string node_id, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}/stats".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23342,14 +23342,14 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, Func<No
 		///<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> NodesStats(string node_id, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}/stats".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23372,14 +23372,14 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, Func<
 		///<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>> NodesStatsAsync(string node_id, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}/stats".F(Encoded(node_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23401,14 +23401,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 		///<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> NodesStatsForAll<T>(string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/stats/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23431,14 +23431,14 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, Func<NodesSta
 		///<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>> NodesStatsForAllAsync<T>(string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/stats/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23462,14 +23462,14 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, Fu
 		///<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> NodesStatsForAll(string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/stats/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23492,14 +23492,14 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric,
 		///<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>> NodesStatsForAllAsync(string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/stats/{0}".F(Encoded(metric));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23522,7 +23522,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(stri
 		///<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> NodesStats<T>(string node_id, string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -23530,7 +23530,7 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, Fun
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23554,7 +23554,7 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, Fun
 		///<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>> NodesStatsAsync<T>(string node_id, string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -23562,7 +23562,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23587,7 +23587,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -23595,7 +23595,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23619,7 +23619,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, strin
 		///<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>> NodesStatsAsync(string node_id, string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -23627,7 +23627,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23650,7 +23650,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 		///<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> NodesStatsForAll<T>(string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
@@ -23658,7 +23658,7 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, string index_
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23682,7 +23682,7 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, string index_
 		///<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>> NodesStatsForAllAsync<T>(string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
@@ -23690,7 +23690,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23715,7 +23715,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, st
 		///<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> NodesStatsForAll(string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
@@ -23723,7 +23723,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23747,7 +23747,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric,
 		///<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>> NodesStatsForAllAsync(string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
@@ -23755,7 +23755,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23779,7 +23779,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(stri
 		///<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> NodesStats<T>(string node_id, string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -23788,7 +23788,7 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23813,7 +23813,7 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, 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 Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -23822,7 +23822,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23848,7 +23848,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -23857,7 +23857,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23882,7 +23882,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, strin
 		///<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>> NodesStatsAsync(string node_id, string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
@@ -23891,7 +23891,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new NodesStatsQueryString());
+				var qs = queryString(new NodesStatsRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23914,7 +23914,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 		///<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> PercolateGet<T>(string index, string type, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -23922,7 +23922,7 @@ public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, Func<
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23946,7 +23946,7 @@ public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, Func<
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -23954,7 +23954,7 @@ public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -23979,7 +23979,7 @@ public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, Func<PercolateQueryString, PercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -23987,7 +23987,7 @@ public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24011,7 +24011,7 @@ public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, strin
 		///<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>> PercolateGetAsync(string index, string type, Func<PercolateQueryString, PercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24019,7 +24019,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string i
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24043,7 +24043,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(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 ElasticsearchResponse<T> PercolateGet<T>(string index, string type, string id, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24052,7 +24052,7 @@ public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24077,7 +24077,7 @@ public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, string id, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24086,7 +24086,7 @@ public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24112,7 +24112,7 @@ public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, string id, Func<PercolateQueryString, PercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24121,7 +24121,7 @@ public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24146,7 +24146,7 @@ public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, strin
 		///<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>> PercolateGetAsync(string index, string type, string id, Func<PercolateQueryString, PercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24155,7 +24155,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string i
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24179,7 +24179,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(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 ElasticsearchResponse<T> Percolate<T>(string index, string type, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Percolate<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24187,7 +24187,7 @@ public ElasticsearchResponse<T> Percolate<T>(string index, string type, object b
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24212,7 +24212,7 @@ public ElasticsearchResponse<T> Percolate<T>(string index, string type, object b
 		///<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>> PercolateAsync<T>(string index, string type, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24220,7 +24220,7 @@ public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24246,7 +24246,7 @@ public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string typ
 		///<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> Percolate(string index, string type, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24254,7 +24254,7 @@ public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string t
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24279,7 +24279,7 @@ public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string t
 		///<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>> PercolateAsync(string index, string type, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24287,7 +24287,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24312,7 +24312,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string inde
 		///<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> Percolate<T>(string index, string type, string id, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Percolate<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24321,7 +24321,7 @@ public ElasticsearchResponse<T> Percolate<T>(string index, string type, string i
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24347,7 +24347,7 @@ public ElasticsearchResponse<T> Percolate<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>> PercolateAsync<T>(string index, string type, string id, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24356,7 +24356,7 @@ public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24383,7 +24383,7 @@ public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string typ
 		///<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> Percolate(string index, string type, string id, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24392,7 +24392,7 @@ public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string t
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24418,7 +24418,7 @@ public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string t
 		///<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>> PercolateAsync(string index, string type, string id, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -24427,7 +24427,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PercolateQueryString());
+				var qs = queryString(new PercolateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24448,13 +24448,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string inde
 		///<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> Ping<T>(Func<PingQueryString, PingQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Ping<T>(Func<PingRequestParameters, PingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PingQueryString());
+				var qs = queryString(new PingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24476,13 +24476,13 @@ public ElasticsearchResponse<T> Ping<T>(Func<PingQueryString, PingQueryString> q
 		///<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>> PingAsync<T>(Func<PingQueryString, PingQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PingAsync<T>(Func<PingRequestParameters, PingRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PingQueryString());
+				var qs = queryString(new PingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24505,13 +24505,13 @@ public Task<ElasticsearchResponse<T>> PingAsync<T>(Func<PingQueryString, PingQue
 		///<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> Ping(Func<PingQueryString, PingQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Ping(Func<PingRequestParameters, PingRequestParameters> queryString = null)
 		{
 			var url = "";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PingQueryString());
+				var qs = queryString(new PingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24533,13 +24533,13 @@ public ElasticsearchResponse<DynamicDictionary> Ping(Func<PingQueryString, PingQ
 		///<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>> PingAsync(Func<PingQueryString, PingQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingRequestParameters, PingRequestParameters> queryString = null)
 		{
 			var url = "";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new PingQueryString());
+				var qs = queryString(new PingRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24560,13 +24560,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingQuerySt
 		///<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> ScrollGet<T>(Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ScrollGet<T>(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_search/scroll";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24588,13 +24588,13 @@ public ElasticsearchResponse<T> ScrollGet<T>(Func<ScrollQueryString, ScrollQuery
 		///<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>> ScrollGetAsync<T>(Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_search/scroll";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24617,13 +24617,13 @@ public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(Func<ScrollQueryString,
 		///<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> ScrollGet(Func<ScrollQueryString, ScrollQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ScrollGet(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
 		{
 			var url = "_search/scroll";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24645,13 +24645,13 @@ public ElasticsearchResponse<DynamicDictionary> ScrollGet(Func<ScrollQueryString
 		///<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>> ScrollGetAsync(Func<ScrollQueryString, ScrollQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
 		{
 			var url = "_search/scroll";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24673,14 +24673,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(Func<Scroll
 		///<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> ScrollGet<T>(string scroll_id, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ScrollGet<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24703,14 +24703,14 @@ public ElasticsearchResponse<T> ScrollGet<T>(string scroll_id, Func<ScrollQueryS
 		///<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>> ScrollGetAsync<T>(string scroll_id, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24734,14 +24734,14 @@ public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(string scroll_id, Func<S
 		///<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> ScrollGet(string scroll_id, Func<ScrollQueryString, ScrollQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ScrollGet(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24764,14 +24764,14 @@ public ElasticsearchResponse<DynamicDictionary> ScrollGet(string scroll_id, Func
 		///<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>> ScrollGetAsync(string scroll_id, Func<ScrollQueryString, ScrollQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24793,13 +24793,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(string scro
 		///<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> Scroll<T>(object body, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Scroll<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_search/scroll".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24822,13 +24822,13 @@ public ElasticsearchResponse<T> Scroll<T>(object body, Func<ScrollQueryString, S
 		///<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>> ScrollAsync<T>(object body, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ScrollAsync<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_search/scroll".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24852,13 +24852,13 @@ public Task<ElasticsearchResponse<T>> ScrollAsync<T>(object body, Func<ScrollQue
 		///<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> Scroll(object body, Func<ScrollQueryString, ScrollQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Scroll(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
 		{
 			var url = "_search/scroll".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24881,13 +24881,13 @@ public ElasticsearchResponse<DynamicDictionary> Scroll(object body, Func<ScrollQ
 		///<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>> ScrollAsync(object body, Func<ScrollQueryString, ScrollQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
 		{
 			var url = "_search/scroll".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24910,14 +24910,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(object body, F
 		///<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> Scroll<T>(string scroll_id, object body, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Scroll<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24941,14 +24941,14 @@ public ElasticsearchResponse<T> Scroll<T>(string scroll_id, object body, Func<Sc
 		///<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>> ScrollAsync<T>(string scroll_id, object body, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ScrollAsync<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -24973,14 +24973,14 @@ public Task<ElasticsearchResponse<T>> ScrollAsync<T>(string scroll_id, object bo
 		///<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> Scroll(string scroll_id, object body, Func<ScrollQueryString, ScrollQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Scroll(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25004,14 +25004,14 @@ public ElasticsearchResponse<DynamicDictionary> Scroll(string scroll_id, object
 		///<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>> ScrollAsync(string scroll_id, object body, Func<ScrollQueryString, ScrollQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new ScrollQueryString());
+				var qs = queryString(new ScrollRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25032,13 +25032,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(string scroll_
 		///<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> SearchGet<T>(Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SearchGet<T>(Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_search";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25060,13 +25060,13 @@ public ElasticsearchResponse<T> SearchGet<T>(Func<SearchQueryString, SearchQuery
 		///<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>> SearchGetAsync<T>(Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_search";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25089,13 +25089,13 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(Func<SearchQueryString,
 		///<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> SearchGet(Func<SearchQueryString, SearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SearchGet(Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			var url = "_search";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25117,13 +25117,13 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(Func<SearchQueryString
 		///<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>> SearchGetAsync(Func<SearchQueryString, SearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			var url = "_search";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25145,14 +25145,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(Func<Search
 		///<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> SearchGet<T>(string index, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SearchGet<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25175,14 +25175,14 @@ public ElasticsearchResponse<T> SearchGet<T>(string index, Func<SearchQueryStrin
 		///<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>> SearchGetAsync<T>(string index, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25206,14 +25206,14 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, Func<Searc
 		///<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> SearchGet(string index, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25236,14 +25236,14 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, Func<Sea
 		///<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>> SearchGetAsync(string index, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25266,7 +25266,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string inde
 		///<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> SearchGet<T>(string index, string type, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SearchGet<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -25274,7 +25274,7 @@ public ElasticsearchResponse<T> SearchGet<T>(string index, string type, Func<Sea
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25298,7 +25298,7 @@ public ElasticsearchResponse<T> SearchGet<T>(string index, string type, Func<Sea
 		///<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>> SearchGetAsync<T>(string index, string type, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -25306,7 +25306,7 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, string typ
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25331,7 +25331,7 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, string typ
 		///<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> SearchGet(string index, string type, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -25339,7 +25339,7 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, string t
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25363,7 +25363,7 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, string t
 		///<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>> SearchGetAsync(string index, string type, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -25371,7 +25371,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string inde
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25393,13 +25393,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string inde
 		///<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> Search<T>(object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Search<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_search".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25422,13 +25422,13 @@ public ElasticsearchResponse<T> Search<T>(object body, Func<SearchQueryString, S
 		///<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>> SearchAsync<T>(object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchAsync<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_search".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25452,13 +25452,13 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(object body, Func<SearchQue
 		///<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> Search(object body, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Search(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			var url = "_search".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25481,13 +25481,13 @@ public ElasticsearchResponse<DynamicDictionary> Search(object body, Func<SearchQ
 		///<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>> SearchAsync(object body, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			var url = "_search".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25510,14 +25510,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(object body, F
 		///<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> Search<T>(string index, object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Search<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25541,14 +25541,14 @@ public ElasticsearchResponse<T> Search<T>(string index, object body, Func<Search
 		///<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>> SearchAsync<T>(string index, object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25573,14 +25573,14 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, object body,
 		///<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> Search(string index, object body, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Search(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25604,14 +25604,14 @@ public ElasticsearchResponse<DynamicDictionary> Search(string index, object body
 		///<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>> SearchAsync(string index, object body, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25635,7 +25635,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index,
 		///<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> Search<T>(string index, string type, object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Search<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -25643,7 +25643,7 @@ public ElasticsearchResponse<T> Search<T>(string index, string type, object body
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25668,7 +25668,7 @@ public ElasticsearchResponse<T> Search<T>(string index, string type, object body
 		///<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>> SearchAsync<T>(string index, string type, object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -25676,7 +25676,7 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25702,7 +25702,7 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, string type,
 		///<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> Search(string index, string type, object body, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Search(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -25710,7 +25710,7 @@ public ElasticsearchResponse<DynamicDictionary> Search(string index, string type
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25735,7 +25735,7 @@ public ElasticsearchResponse<DynamicDictionary> Search(string index, string type
 		///<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>> SearchAsync(string index, string type, object body, Func<SearchQueryString, SearchQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -25743,7 +25743,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SearchQueryString());
+				var qs = queryString(new SearchRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25767,7 +25767,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index,
 		///<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> SnapshotCreate<T>(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotCreate<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -25775,7 +25775,7 @@ public ElasticsearchResponse<T> SnapshotCreate<T>(string repository, string snap
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateQueryString());
+				var qs = queryString(new SnapshotCreateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25800,7 +25800,7 @@ public ElasticsearchResponse<T> SnapshotCreate<T>(string repository, string snap
 		///<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>> SnapshotCreateAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotCreateAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -25808,7 +25808,7 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateAsync<T>(string repository,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateQueryString());
+				var qs = queryString(new SnapshotCreateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25834,7 +25834,7 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateAsync<T>(string repository,
 		///<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> SnapshotCreate(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotCreate(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -25842,7 +25842,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreate(string repository
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateQueryString());
+				var qs = queryString(new SnapshotCreateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25867,7 +25867,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreate(string repository
 		///<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>> SnapshotCreateAsync(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -25875,7 +25875,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateAsync(string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateQueryString());
+				var qs = queryString(new SnapshotCreateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25899,7 +25899,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateAsync(string
 		///<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> SnapshotCreatePost<T>(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotCreatePost<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -25907,7 +25907,7 @@ public ElasticsearchResponse<T> SnapshotCreatePost<T>(string repository, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateQueryString());
+				var qs = queryString(new SnapshotCreateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25932,7 +25932,7 @@ public ElasticsearchResponse<T> SnapshotCreatePost<T>(string repository, string
 		///<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>> SnapshotCreatePostAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotCreatePostAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -25940,7 +25940,7 @@ public Task<ElasticsearchResponse<T>> SnapshotCreatePostAsync<T>(string reposito
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateQueryString());
+				var qs = queryString(new SnapshotCreateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25966,7 +25966,7 @@ public Task<ElasticsearchResponse<T>> SnapshotCreatePostAsync<T>(string reposito
 		///<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> SnapshotCreatePost(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotCreatePost(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -25974,7 +25974,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreatePost(string reposi
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateQueryString());
+				var qs = queryString(new SnapshotCreateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -25999,7 +25999,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreatePost(string reposi
 		///<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>> SnapshotCreatePostAsync(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreatePostAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26007,7 +26007,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreatePostAsync(st
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateQueryString());
+				var qs = queryString(new SnapshotCreateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26030,14 +26030,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreatePostAsync(st
 		///<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> SnapshotCreateRepository<T>(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotCreateRepository<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryQueryString());
+				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26061,14 +26061,14 @@ public ElasticsearchResponse<T> SnapshotCreateRepository<T>(string repository, o
 		///<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>> SnapshotCreateRepositoryAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryQueryString());
+				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26093,14 +26093,14 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryAsync<T>(string re
 		///<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> SnapshotCreateRepository(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepository(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryQueryString());
+				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26124,14 +26124,14 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepository(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryAsync(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryQueryString());
+				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26154,14 +26154,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryAs
 		///<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> SnapshotCreateRepositoryPost<T>(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotCreateRepositoryPost<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryQueryString());
+				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26185,14 +26185,14 @@ public ElasticsearchResponse<T> SnapshotCreateRepositoryPost<T>(string repositor
 		///<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>> SnapshotCreateRepositoryPostAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryPostAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryQueryString());
+				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26217,14 +26217,14 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryPostAsync<T>(strin
 		///<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> SnapshotCreateRepositoryPost(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepositoryPost(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryQueryString());
+				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26248,14 +26248,14 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepositoryPost(str
 		///<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>> SnapshotCreateRepositoryPostAsync(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryPostAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryQueryString());
+				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26278,7 +26278,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryPo
 		///<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> SnapshotDelete<T>(string repository, string snapshot, Func<SnapshotDeleteQueryString, SnapshotDeleteQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotDelete<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26286,7 +26286,7 @@ public ElasticsearchResponse<T> SnapshotDelete<T>(string repository, string snap
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotDeleteQueryString());
+				var qs = queryString(new SnapshotDeleteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26310,7 +26310,7 @@ public ElasticsearchResponse<T> SnapshotDelete<T>(string repository, string snap
 		///<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>> SnapshotDeleteAsync<T>(string repository, string snapshot, Func<SnapshotDeleteQueryString, SnapshotDeleteQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotDeleteAsync<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26318,7 +26318,7 @@ public Task<ElasticsearchResponse<T>> SnapshotDeleteAsync<T>(string repository,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotDeleteQueryString());
+				var qs = queryString(new SnapshotDeleteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26343,7 +26343,7 @@ public Task<ElasticsearchResponse<T>> SnapshotDeleteAsync<T>(string repository,
 		///<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> SnapshotDelete(string repository, string snapshot, Func<SnapshotDeleteQueryString, SnapshotDeleteQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotDelete(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26351,7 +26351,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotDelete(string repository
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotDeleteQueryString());
+				var qs = queryString(new SnapshotDeleteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26375,7 +26375,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotDelete(string repository
 		///<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>> SnapshotDeleteAsync(string repository, string snapshot, Func<SnapshotDeleteQueryString, SnapshotDeleteQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteAsync(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26383,7 +26383,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteAsync(string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotDeleteQueryString());
+				var qs = queryString(new SnapshotDeleteRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26405,14 +26405,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteAsync(string
 		///<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> SnapshotDeleteRepository<T>(string repository, Func<SnapshotDeleteRepositoryQueryString, SnapshotDeleteRepositoryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotDeleteRepository<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotDeleteRepositoryQueryString());
+				var qs = queryString(new SnapshotDeleteRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26435,14 +26435,14 @@ public ElasticsearchResponse<T> SnapshotDeleteRepository<T>(string repository, F
 		///<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>> SnapshotDeleteRepositoryAsync<T>(string repository, Func<SnapshotDeleteRepositoryQueryString, SnapshotDeleteRepositoryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryAsync<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotDeleteRepositoryQueryString());
+				var qs = queryString(new SnapshotDeleteRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26466,14 +26466,14 @@ public Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryAsync<T>(string re
 		///<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> SnapshotDeleteRepository(string repository, Func<SnapshotDeleteRepositoryQueryString, SnapshotDeleteRepositoryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotDeleteRepository(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotDeleteRepositoryQueryString());
+				var qs = queryString(new SnapshotDeleteRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26496,14 +26496,14 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotDeleteRepository(string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteRepositoryAsync(string repository, Func<SnapshotDeleteRepositoryQueryString, SnapshotDeleteRepositoryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteRepositoryAsync(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotDeleteRepositoryQueryString());
+				var qs = queryString(new SnapshotDeleteRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26526,7 +26526,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteRepositoryAs
 		///<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> SnapshotGet<T>(string repository, string snapshot, Func<SnapshotGetQueryString, SnapshotGetQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotGet<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26534,7 +26534,7 @@ public ElasticsearchResponse<T> SnapshotGet<T>(string repository, string snapsho
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetQueryString());
+				var qs = queryString(new SnapshotGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26558,7 +26558,7 @@ public ElasticsearchResponse<T> SnapshotGet<T>(string repository, string snapsho
 		///<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>> SnapshotGetAsync<T>(string repository, string snapshot, Func<SnapshotGetQueryString, SnapshotGetQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotGetAsync<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26566,7 +26566,7 @@ public Task<ElasticsearchResponse<T>> SnapshotGetAsync<T>(string repository, str
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetQueryString());
+				var qs = queryString(new SnapshotGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26591,7 +26591,7 @@ public Task<ElasticsearchResponse<T>> SnapshotGetAsync<T>(string repository, str
 		///<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> SnapshotGet(string repository, string snapshot, Func<SnapshotGetQueryString, SnapshotGetQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotGet(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26599,7 +26599,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGet(string repository, s
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetQueryString());
+				var qs = queryString(new SnapshotGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26623,7 +26623,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGet(string repository, s
 		///<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>> SnapshotGetAsync(string repository, string snapshot, Func<SnapshotGetQueryString, SnapshotGetQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetAsync(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26631,7 +26631,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetAsync(string re
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetQueryString());
+				var qs = queryString(new SnapshotGetRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26652,13 +26652,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetAsync(string re
 		///<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> SnapshotGetRepository<T>(Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotGetRepository<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_snapshot";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryQueryString());
+				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26680,13 +26680,13 @@ public ElasticsearchResponse<T> SnapshotGetRepository<T>(Func<SnapshotGetReposit
 		///<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>> SnapshotGetRepositoryAsync<T>(Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_snapshot";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryQueryString());
+				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26709,13 +26709,13 @@ public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(Func<Snapsho
 		///<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> SnapshotGetRepository(Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null)
 		{
 			var url = "_snapshot";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryQueryString());
+				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26737,13 +26737,13 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(Func<Snaps
 		///<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>> SnapshotGetRepositoryAsync(Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null)
 		{
 			var url = "_snapshot";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryQueryString());
+				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26765,14 +26765,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync
 		///<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> SnapshotGetRepository<T>(string repository, Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotGetRepository<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryQueryString());
+				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26795,14 +26795,14 @@ public ElasticsearchResponse<T> SnapshotGetRepository<T>(string repository, Func
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(string repository, Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryQueryString());
+				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26826,14 +26826,14 @@ public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(string repos
 		///<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> SnapshotGetRepository(string repository, Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryQueryString());
+				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26856,14 +26856,14 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(string rep
 		///<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>> SnapshotGetRepositoryAsync(string repository, Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryQueryString());
+				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26887,7 +26887,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync
 		///<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> SnapshotRestore<T>(string repository, string snapshot, object body, Func<SnapshotRestoreQueryString, SnapshotRestoreQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotRestore<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26895,7 +26895,7 @@ public ElasticsearchResponse<T> SnapshotRestore<T>(string repository, string sna
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotRestoreQueryString());
+				var qs = queryString(new SnapshotRestoreRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26920,7 +26920,7 @@ public ElasticsearchResponse<T> SnapshotRestore<T>(string repository, string sna
 		///<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>> SnapshotRestoreAsync<T>(string repository, string snapshot, object body, Func<SnapshotRestoreQueryString, SnapshotRestoreQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotRestoreAsync<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null, object deserializationState = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26928,7 +26928,7 @@ public Task<ElasticsearchResponse<T>> SnapshotRestoreAsync<T>(string repository,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotRestoreQueryString());
+				var qs = queryString(new SnapshotRestoreRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26954,7 +26954,7 @@ public Task<ElasticsearchResponse<T>> SnapshotRestoreAsync<T>(string repository,
 		///<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> SnapshotRestore(string repository, string snapshot, object body, Func<SnapshotRestoreQueryString, SnapshotRestoreQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotRestore(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26962,7 +26962,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotRestore(string repositor
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotRestoreQueryString());
+				var qs = queryString(new SnapshotRestoreRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -26987,7 +26987,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotRestore(string repositor
 		///<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>> SnapshotRestoreAsync(string repository, string snapshot, object body, Func<SnapshotRestoreQueryString, SnapshotRestoreQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotRestoreAsync(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
@@ -26995,7 +26995,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotRestoreAsync(strin
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SnapshotRestoreQueryString());
+				var qs = queryString(new SnapshotRestoreRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27017,13 +27017,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotRestoreAsync(strin
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> Suggest<T>(object body, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Suggest<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_suggest".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27046,13 +27046,13 @@ public ElasticsearchResponse<T> Suggest<T>(object body, Func<SuggestQueryString,
 		///<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>> SuggestAsync<T>(object body, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SuggestAsync<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_suggest".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27076,13 +27076,13 @@ public Task<ElasticsearchResponse<T>> SuggestAsync<T>(object body, Func<SuggestQ
 		///<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> Suggest(object body, Func<SuggestQueryString, SuggestQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Suggest(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
 		{
 			var url = "_suggest".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27105,13 +27105,13 @@ public ElasticsearchResponse<DynamicDictionary> Suggest(object body, Func<Sugges
 		///<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>> SuggestAsync(object body, Func<SuggestQueryString, SuggestQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
 		{
 			var url = "_suggest".F();
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27134,14 +27134,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(object body,
 		///<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> Suggest<T>(string index, object body, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Suggest<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27165,14 +27165,14 @@ public ElasticsearchResponse<T> Suggest<T>(string index, object body, Func<Sugge
 		///<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>> SuggestAsync<T>(string index, object body, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SuggestAsync<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27197,14 +27197,14 @@ public Task<ElasticsearchResponse<T>> SuggestAsync<T>(string index, object body,
 		///<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> Suggest(string index, object body, Func<SuggestQueryString, SuggestQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Suggest(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27228,14 +27228,14 @@ public ElasticsearchResponse<DynamicDictionary> Suggest(string index, object bod
 		///<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>> SuggestAsync(string index, object body, Func<SuggestQueryString, SuggestQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27256,13 +27256,13 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(string index,
 		///<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> SuggestGet<T>(Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SuggestGet<T>(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_suggest";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27284,13 +27284,13 @@ public ElasticsearchResponse<T> SuggestGet<T>(Func<SuggestQueryString, SuggestQu
 		///<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>> SuggestGetAsync<T>(Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
 		{
 			var url = "_suggest";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27313,13 +27313,13 @@ public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(Func<SuggestQueryString
 		///<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> SuggestGet(Func<SuggestQueryString, SuggestQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SuggestGet(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
 		{
 			var url = "_suggest";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27341,13 +27341,13 @@ public ElasticsearchResponse<DynamicDictionary> SuggestGet(Func<SuggestQueryStri
 		///<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>> SuggestGetAsync(Func<SuggestQueryString, SuggestQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
 		{
 			var url = "_suggest";
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27369,14 +27369,14 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(Func<Sugge
 		///<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> SuggestGet<T>(string index, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SuggestGet<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27399,14 +27399,14 @@ public ElasticsearchResponse<T> SuggestGet<T>(string index, Func<SuggestQueryStr
 		///<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>> SuggestGetAsync<T>(string index, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27430,14 +27430,14 @@ public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(string index, Func<Sugg
 		///<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> SuggestGet(string index, Func<SuggestQueryString, SuggestQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SuggestGet(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27460,14 +27460,14 @@ public ElasticsearchResponse<DynamicDictionary> SuggestGet(string index, Func<Su
 		///<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>> SuggestGetAsync(string index, Func<SuggestQueryString, SuggestQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new SuggestQueryString());
+				var qs = queryString(new SuggestRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27491,7 +27491,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(string ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, string id, Func<TermvectorQueryString, TermvectorQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27500,7 +27500,7 @@ public ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new TermvectorQueryString());
+				var qs = queryString(new TermvectorRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27525,7 +27525,7 @@ public ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, stri
 		///<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>> TermvectorGetAsync<T>(string index, string type, string id, Func<TermvectorQueryString, TermvectorQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> TermvectorGetAsync<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27534,7 +27534,7 @@ public Task<ElasticsearchResponse<T>> TermvectorGetAsync<T>(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new TermvectorQueryString());
+				var qs = queryString(new TermvectorRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27560,7 +27560,7 @@ public Task<ElasticsearchResponse<T>> TermvectorGetAsync<T>(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, string type, string id, Func<TermvectorQueryString, TermvectorQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27569,7 +27569,7 @@ public ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, stri
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new TermvectorQueryString());
+				var qs = queryString(new TermvectorRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27594,7 +27594,7 @@ public ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, stri
 		///<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>> TermvectorGetAsync(string index, string type, string id, Func<TermvectorQueryString, TermvectorQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorGetAsync(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27603,7 +27603,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorGetAsync(string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new TermvectorQueryString());
+				var qs = queryString(new TermvectorRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27628,7 +27628,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorGetAsync(string
 		///<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> Termvector<T>(string index, string type, string id, object body, Func<TermvectorQueryString, TermvectorQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Termvector<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27637,7 +27637,7 @@ public ElasticsearchResponse<T> Termvector<T>(string index, string type, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new TermvectorQueryString());
+				var qs = queryString(new TermvectorRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27663,7 +27663,7 @@ public ElasticsearchResponse<T> Termvector<T>(string index, string type, string
 		///<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>> TermvectorAsync<T>(string index, string type, string id, object body, Func<TermvectorQueryString, TermvectorQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> TermvectorAsync<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27672,7 +27672,7 @@ public Task<ElasticsearchResponse<T>> TermvectorAsync<T>(string index, string ty
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new TermvectorQueryString());
+				var qs = queryString(new TermvectorRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27699,7 +27699,7 @@ public Task<ElasticsearchResponse<T>> TermvectorAsync<T>(string index, string ty
 		///<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> Termvector(string index, string type, string id, object body, Func<TermvectorQueryString, TermvectorQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Termvector(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27708,7 +27708,7 @@ public ElasticsearchResponse<DynamicDictionary> Termvector(string index, string
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new TermvectorQueryString());
+				var qs = queryString(new TermvectorRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27734,7 +27734,7 @@ public ElasticsearchResponse<DynamicDictionary> Termvector(string index, string
 		///<para> - i.e result.Response.hits.hits[0].property.nested["nested_deeper"]</para>
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
-		public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string index, string type, string id, object body, Func<TermvectorQueryString, TermvectorQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27743,7 +27743,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string ind
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new TermvectorQueryString());
+				var qs = queryString(new TermvectorRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27768,7 +27768,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string ind
 		///<para> - If T is of type byte[] deserialization will be shortcircuited</para>
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
-		public ElasticsearchResponse<T> Update<T>(string index, string type, string id, object body, Func<UpdateQueryString, UpdateQueryString> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Update<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27777,7 +27777,7 @@ public ElasticsearchResponse<T> Update<T>(string index, string type, string id,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateQueryString());
+				var qs = queryString(new UpdateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27803,7 +27803,7 @@ public ElasticsearchResponse<T> Update<T>(string index, string type, string id,
 		///<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>> UpdateAsync<T>(string index, string type, string id, object body, Func<UpdateQueryString, UpdateQueryString> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> UpdateAsync<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null, object deserializationState = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27812,7 +27812,7 @@ public Task<ElasticsearchResponse<T>> UpdateAsync<T>(string index, string type,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateQueryString());
+				var qs = queryString(new UpdateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27839,7 +27839,7 @@ public Task<ElasticsearchResponse<T>> UpdateAsync<T>(string index, string type,
 		///<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> Update(string index, string type, string id, object body, Func<UpdateQueryString, UpdateQueryString> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Update(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27848,7 +27848,7 @@ public ElasticsearchResponse<DynamicDictionary> Update(string index, string type
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateQueryString());
+				var qs = queryString(new UpdateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
@@ -27874,7 +27874,7 @@ public ElasticsearchResponse<DynamicDictionary> Update(string index, string type
 		///<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>> UpdateAsync(string index, string type, string id, object body, Func<UpdateQueryString, UpdateQueryString> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> UpdateAsync(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
@@ -27883,7 +27883,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> UpdateAsync(string index,
 			NameValueCollection nv = null;
 			if (queryString != null)
 			{
-				var qs = queryString(new UpdateQueryString());
+				var qs = queryString(new UpdateRequestParameters());
 				if (qs != null) nv = this.ToNameValueCollection(qs);
 			}
 
diff --git a/src/Elasticsearch.Net/ElasticsearchClient.cs b/src/Elasticsearch.Net/ElasticsearchClient.cs
index cf1925f317e..18fdf20274a 100644
--- a/src/Elasticsearch.Net/ElasticsearchClient.cs
+++ b/src/Elasticsearch.Net/ElasticsearchClient.cs
@@ -49,8 +49,8 @@ public ElasticsearchClient(
 				this.Transport.Sniff(fromStartup: true);
 		}
 
-		protected NameValueCollection ToNameValueCollection<TQueryString>(FluentQueryString<TQueryString> qs)
-			where TQueryString : FluentQueryString<TQueryString>
+		protected NameValueCollection ToNameValueCollection<TQueryString>(FluentRequestParameters<TQueryString> qs)
+			where TQueryString : FluentRequestParameters<TQueryString>
 		{
 			if (qs == null)
 				return null;
diff --git a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
index 990d37efeb2..6b135a03a9d 100644
--- a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
@@ -37,7 +37,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Bulk<T>(object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Bulk<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -52,7 +52,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> BulkAsync<T>(object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -69,7 +69,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Bulk(object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Bulk(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -86,7 +86,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -102,7 +102,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Bulk<T>(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Bulk<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -118,7 +118,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -136,7 +136,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Bulk(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Bulk(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -154,7 +154,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -171,7 +171,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Bulk<T>(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Bulk<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -188,7 +188,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -207,7 +207,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Bulk(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Bulk(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -226,7 +226,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -241,7 +241,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> BulkPut<T>(object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> BulkPut<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -256,7 +256,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> BulkPutAsync<T>(object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkPutAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -273,7 +273,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> BulkPut(object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> BulkPut(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -290,7 +290,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -306,7 +306,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> BulkPut<T>(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> BulkPut<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -322,7 +322,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -340,7 +340,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> BulkPut(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> BulkPut(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -358,7 +358,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -375,7 +375,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> BulkPut<T>(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> BulkPut<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -392,7 +392,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -411,7 +411,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> BulkPut(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> BulkPut(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -430,7 +430,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, string type, object body, Func<BulkQueryString, BulkQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -444,7 +444,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatAliases<T>(Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatAliases<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/aliases
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -458,7 +458,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -474,7 +474,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatAliases(Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/aliases
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -490,7 +490,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -505,7 +505,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatAliases<T>(string name, Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatAliases<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -520,7 +520,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(string name, Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -537,7 +537,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatAliases(string name, Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -554,7 +554,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(string name, Func<CatAliasesQueryString, CatAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -568,7 +568,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatAllocation<T>(Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatAllocation<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -582,7 +582,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -598,7 +598,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatAllocation(Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -614,7 +614,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -629,7 +629,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatAllocation<T>(string node_id, Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatAllocation<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -644,7 +644,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(string node_id, Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -661,7 +661,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatAllocation(string node_id, Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -678,7 +678,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(string node_id, Func<CatAllocationQueryString, CatAllocationQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -692,7 +692,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatCount<T>(Func<CatCountQueryString, CatCountQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatCount<T>(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -706,7 +706,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatCountAsync<T>(Func<CatCountQueryString, CatCountQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatCountAsync<T>(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -722,7 +722,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatCount(Func<CatCountQueryString, CatCountQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -738,7 +738,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(Func<CatCountQueryString, CatCountQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -753,7 +753,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatCount<T>(string index, Func<CatCountQueryString, CatCountQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatCount<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -768,7 +768,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatCountAsync<T>(string index, Func<CatCountQueryString, CatCountQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatCountAsync<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -785,7 +785,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatCount(string index, Func<CatCountQueryString, CatCountQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -802,7 +802,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(string index, Func<CatCountQueryString, CatCountQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -816,7 +816,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatHealth<T>(Func<CatHealthQueryString, CatHealthQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatHealth<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -830,7 +830,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatHealthAsync<T>(Func<CatHealthQueryString, CatHealthQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatHealthAsync<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -846,7 +846,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatHealth(Func<CatHealthQueryString, CatHealthQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -862,7 +862,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatHealthAsync(Func<CatHealthQueryString, CatHealthQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -876,7 +876,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatHelp<T>(Func<CatHelpQueryString, CatHelpQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatHelp<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -890,7 +890,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatHelpAsync<T>(Func<CatHelpQueryString, CatHelpQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatHelpAsync<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -906,7 +906,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatHelp(Func<CatHelpQueryString, CatHelpQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -922,7 +922,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatHelpAsync(Func<CatHelpQueryString, CatHelpQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -936,7 +936,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatIndices<T>(Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatIndices<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -950,7 +950,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -966,7 +966,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatIndices(Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -982,7 +982,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -997,7 +997,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatIndices<T>(string index, Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatIndices<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1012,7 +1012,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(string index, Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1029,7 +1029,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatIndices(string index, Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1046,7 +1046,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(string index, Func<CatIndicesQueryString, CatIndicesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1060,7 +1060,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatMaster<T>(Func<CatMasterQueryString, CatMasterQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatMaster<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1074,7 +1074,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatMasterAsync<T>(Func<CatMasterQueryString, CatMasterQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatMasterAsync<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1090,7 +1090,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatMaster(Func<CatMasterQueryString, CatMasterQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1106,7 +1106,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatMasterAsync(Func<CatMasterQueryString, CatMasterQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1120,7 +1120,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatNodes<T>(Func<CatNodesQueryString, CatNodesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatNodes<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1134,7 +1134,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatNodesAsync<T>(Func<CatNodesQueryString, CatNodesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatNodesAsync<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1150,7 +1150,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatNodes(Func<CatNodesQueryString, CatNodesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1166,7 +1166,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatNodesAsync(Func<CatNodesQueryString, CatNodesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1180,7 +1180,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatPendingTasks<T>(Func<CatPendingTasksQueryString, CatPendingTasksQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatPendingTasks<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1194,7 +1194,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatPendingTasksAsync<T>(Func<CatPendingTasksQueryString, CatPendingTasksQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatPendingTasksAsync<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1210,7 +1210,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatPendingTasks(Func<CatPendingTasksQueryString, CatPendingTasksQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1226,7 +1226,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatPendingTasksAsync(Func<CatPendingTasksQueryString, CatPendingTasksQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1240,7 +1240,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatRecovery<T>(Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatRecovery<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1254,7 +1254,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1270,7 +1270,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatRecovery(Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1286,7 +1286,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1301,7 +1301,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatRecovery<T>(string index, Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatRecovery<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1316,7 +1316,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(string index, Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1333,7 +1333,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatRecovery(string index, Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1350,7 +1350,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(string index, Func<CatRecoveryQueryString, CatRecoveryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1364,7 +1364,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatShards<T>(Func<CatShardsQueryString, CatShardsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatShards<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1378,7 +1378,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatShardsAsync<T>(Func<CatShardsQueryString, CatShardsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatShardsAsync<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1394,7 +1394,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatShards(Func<CatShardsQueryString, CatShardsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1410,7 +1410,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(Func<CatShardsQueryString, CatShardsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1425,7 +1425,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatShards<T>(string index, Func<CatShardsQueryString, CatShardsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatShards<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1440,7 +1440,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatShardsAsync<T>(string index, Func<CatShardsQueryString, CatShardsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatShardsAsync<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1457,7 +1457,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatShards(string index, Func<CatShardsQueryString, CatShardsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1474,7 +1474,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(string index, Func<CatShardsQueryString, CatShardsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1488,7 +1488,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CatThreadPool<T>(Func<CatThreadPoolQueryString, CatThreadPoolQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatThreadPool<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1502,7 +1502,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CatThreadPoolAsync<T>(Func<CatThreadPoolQueryString, CatThreadPoolQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatThreadPoolAsync<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1518,7 +1518,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatThreadPool(Func<CatThreadPoolQueryString, CatThreadPoolQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1534,7 +1534,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatThreadPoolAsync(Func<CatThreadPoolQueryString, CatThreadPoolQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1549,7 +1549,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClearScroll<T>(string scroll_id, Func<ClearScrollQueryString, ClearScrollQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClearScroll<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1564,7 +1564,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClearScrollAsync<T>(string scroll_id, Func<ClearScrollQueryString, ClearScrollQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClearScrollAsync<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1581,7 +1581,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClearScroll(string scroll_id, Func<ClearScrollQueryString, ClearScrollQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClearScroll(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1598,7 +1598,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClearScrollAsync(string scroll_id, Func<ClearScrollQueryString, ClearScrollQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClearScrollAsync(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1612,7 +1612,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterGetSettings<T>(Func<ClusterGetSettingsQueryString, ClusterGetSettingsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterGetSettings<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1626,7 +1626,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterGetSettingsAsync<T>(Func<ClusterGetSettingsQueryString, ClusterGetSettingsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterGetSettingsAsync<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1642,7 +1642,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterGetSettings(Func<ClusterGetSettingsQueryString, ClusterGetSettingsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterGetSettings(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1658,7 +1658,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterGetSettingsAsync(Func<ClusterGetSettingsQueryString, ClusterGetSettingsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterGetSettingsAsync(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/health
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1672,7 +1672,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterHealth<T>(Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterHealth<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/health
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1686,7 +1686,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/health
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1702,7 +1702,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterHealth(Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterHealth(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/health
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1718,7 +1718,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/health/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1733,7 +1733,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterHealth<T>(string index, Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterHealth<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/health/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1748,7 +1748,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(string index, Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/health/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1765,7 +1765,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterHealth(string index, Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterHealth(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/health/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1782,7 +1782,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(string index, Func<ClusterHealthQueryString, ClusterHealthQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/pending_tasks
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1796,7 +1796,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterPendingTasks<T>(Func<ClusterPendingTasksQueryString, ClusterPendingTasksQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterPendingTasks<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/pending_tasks
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1810,7 +1810,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterPendingTasksAsync<T>(Func<ClusterPendingTasksQueryString, ClusterPendingTasksQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterPendingTasksAsync<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/pending_tasks
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1826,7 +1826,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterPendingTasks(Func<ClusterPendingTasksQueryString, ClusterPendingTasksQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterPendingTasks(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/pending_tasks
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1842,7 +1842,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterPendingTasksAsync(Func<ClusterPendingTasksQueryString, ClusterPendingTasksQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterPendingTasksAsync(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_cluster/settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1857,7 +1857,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterPutSettings<T>(object body, Func<ClusterPutSettingsQueryString, ClusterPutSettingsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterPutSettings<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_cluster/settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1872,7 +1872,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterPutSettingsAsync<T>(object body, Func<ClusterPutSettingsQueryString, ClusterPutSettingsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterPutSettingsAsync<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_cluster/settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1889,7 +1889,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterPutSettings(object body, Func<ClusterPutSettingsQueryString, ClusterPutSettingsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterPutSettings(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_cluster/settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1906,7 +1906,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterPutSettingsAsync(object body, Func<ClusterPutSettingsQueryString, ClusterPutSettingsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterPutSettingsAsync(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_cluster/reroute
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1921,7 +1921,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterReroute<T>(object body, Func<ClusterRerouteQueryString, ClusterRerouteQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterReroute<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_cluster/reroute
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1936,7 +1936,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterRerouteAsync<T>(object body, Func<ClusterRerouteQueryString, ClusterRerouteQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterRerouteAsync<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_cluster/reroute
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1953,7 +1953,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterReroute(object body, Func<ClusterRerouteQueryString, ClusterRerouteQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterReroute(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_cluster/reroute
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1970,7 +1970,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterRerouteAsync(object body, Func<ClusterRerouteQueryString, ClusterRerouteQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterRerouteAsync(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/state
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1984,7 +1984,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterState<T>(Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterState<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/state
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1998,7 +1998,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/state
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2014,7 +2014,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterState(Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterState(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/state
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2030,7 +2030,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2045,7 +2045,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterState<T>(string metric, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterState<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2060,7 +2060,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2077,7 +2077,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2094,7 +2094,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2110,7 +2110,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterState<T>(string metric, string index, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterState<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2126,7 +2126,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, string index, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2144,7 +2144,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, string index, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2162,7 +2162,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, string index, Func<ClusterStateQueryString, ClusterStateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2176,7 +2176,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterStats<T>(Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterStats<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2190,7 +2190,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2206,7 +2206,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterStats(Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterStats(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2222,7 +2222,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/stats/nodes/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2237,7 +2237,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ClusterStats<T>(string node_id, Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterStats<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/stats/nodes/{node_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2252,7 +2252,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(string node_id, Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/stats/nodes/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2269,7 +2269,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ClusterStats(string node_id, Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterStats(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/stats/nodes/{node_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2286,7 +2286,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(string node_id, Func<ClusterStatsQueryString, ClusterStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2301,7 +2301,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Count<T>(object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Count<T>(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2316,7 +2316,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountAsync<T>(object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountAsync<T>(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2333,7 +2333,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Count(object body, Func<CountQueryString, CountQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Count(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2350,7 +2350,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(object body, Func<CountQueryString, CountQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2366,7 +2366,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Count<T>(string index, object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Count<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2382,7 +2382,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountAsync<T>(string index, object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountAsync<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2400,7 +2400,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Count(string index, object body, Func<CountQueryString, CountQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Count(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2418,7 +2418,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, object body, Func<CountQueryString, CountQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2435,7 +2435,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Count<T>(string index, string type, object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Count<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2452,7 +2452,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountAsync<T>(string index, string type, object body, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountAsync<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2471,7 +2471,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Count(string index, string type, object body, Func<CountQueryString, CountQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Count(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2490,7 +2490,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, string type, object body, Func<CountQueryString, CountQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2504,7 +2504,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CountGet<T>(Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountGet<T>(Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2518,7 +2518,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountGetAsync<T>(Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountGetAsync<T>(Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2534,7 +2534,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CountGet(Func<CountQueryString, CountQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountGet(Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2550,7 +2550,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(Func<CountQueryString, CountQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2565,7 +2565,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CountGet<T>(string index, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountGet<T>(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2580,7 +2580,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2597,7 +2597,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CountGet(string index, Func<CountQueryString, CountQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountGet(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2614,7 +2614,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, Func<CountQueryString, CountQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2630,7 +2630,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CountGet<T>(string index, string type, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountGet<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2646,7 +2646,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, string type, Func<CountQueryString, CountQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2664,7 +2664,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CountGet(string index, string type, Func<CountQueryString, CountQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountGet(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2682,7 +2682,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, string type, Func<CountQueryString, CountQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2698,7 +2698,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2714,7 +2714,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2732,7 +2732,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2750,7 +2750,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2767,7 +2767,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, string id, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2784,7 +2784,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, string id, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2803,7 +2803,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, string id, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2822,7 +2822,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, string id, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2839,7 +2839,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CountPercolate<T>(string index, string type, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountPercolate<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2856,7 +2856,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2875,7 +2875,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2894,7 +2894,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2912,7 +2912,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> CountPercolate<T>(string index, string type, string id, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountPercolate<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2930,7 +2930,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, string id, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2950,7 +2950,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, string id, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2970,7 +2970,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, string id, object body, Func<CountPercolateQueryString, CountPercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2987,7 +2987,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Delete<T>(string index, string type, string id, Func<DeleteQueryString, DeleteQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Delete<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3004,7 +3004,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> DeleteAsync<T>(string index, string type, string id, Func<DeleteQueryString, DeleteQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> DeleteAsync<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3023,7 +3023,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Delete(string index, string type, string id, Func<DeleteQueryString, DeleteQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Delete(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3042,7 +3042,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> DeleteAsync(string index, string type, string id, Func<DeleteQueryString, DeleteQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> DeleteAsync(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/_query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3058,7 +3058,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> DeleteByQuery<T>(string index, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> DeleteByQuery<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/_query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3074,7 +3074,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/_query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3092,7 +3092,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/_query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3110,7 +3110,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3127,7 +3127,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> DeleteByQuery<T>(string index, string type, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> DeleteByQuery<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3144,7 +3144,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, string type, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3163,7 +3163,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, string type, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3182,7 +3182,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, string type, object body, Func<DeleteByQueryQueryString, DeleteByQueryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3199,7 +3199,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Exists<T>(string index, string type, string id, Func<ExistsQueryString, ExistsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Exists<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3216,7 +3216,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ExistsAsync<T>(string index, string type, string id, Func<ExistsQueryString, ExistsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ExistsAsync<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3235,7 +3235,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Exists(string index, string type, string id, Func<ExistsQueryString, ExistsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Exists(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3254,7 +3254,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ExistsAsync(string index, string type, string id, Func<ExistsQueryString, ExistsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ExistsAsync(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3271,7 +3271,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ExplainGet<T>(string index, string type, string id, Func<ExplainQueryString, ExplainQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ExplainGet<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3288,7 +3288,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ExplainGetAsync<T>(string index, string type, string id, Func<ExplainQueryString, ExplainQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ExplainGetAsync<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3307,7 +3307,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ExplainGet(string index, string type, string id, Func<ExplainQueryString, ExplainQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ExplainGet(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3326,7 +3326,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string index, string type, string id, Func<ExplainQueryString, ExplainQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3344,7 +3344,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Explain<T>(string index, string type, string id, object body, Func<ExplainQueryString, ExplainQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Explain<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3362,7 +3362,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ExplainAsync<T>(string index, string type, string id, object body, Func<ExplainQueryString, ExplainQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ExplainAsync<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3382,7 +3382,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Explain(string index, string type, string id, object body, Func<ExplainQueryString, ExplainQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Explain(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3402,7 +3402,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ExplainAsync(string index, string type, string id, object body, Func<ExplainQueryString, ExplainQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ExplainAsync(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3419,7 +3419,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Get<T>(string index, string type, string id, Func<GetQueryString, GetQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Get<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3436,7 +3436,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> GetAsync<T>(string index, string type, string id, Func<GetQueryString, GetQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> GetAsync<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3455,7 +3455,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Get(string index, string type, string id, Func<GetQueryString, GetQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Get(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3474,7 +3474,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, string type, string id, Func<GetQueryString, GetQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_source
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3491,7 +3491,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> GetSource<T>(string index, string type, string id, Func<SourceQueryString, SourceQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> GetSource<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<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.
@@ -3508,7 +3508,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> GetSourceAsync<T>(string index, string type, string id, Func<SourceQueryString, SourceQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> GetSourceAsync<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_source
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3527,7 +3527,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> GetSource(string index, string type, string id, Func<SourceQueryString, SourceQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> GetSource(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_source
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3546,7 +3546,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string index, string type, string id, Func<SourceQueryString, SourceQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3563,7 +3563,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Index<T>(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Index<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3580,7 +3580,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3599,7 +3599,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Index(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Index(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3618,7 +3618,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3636,7 +3636,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Index<T>(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Index<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3654,7 +3654,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3674,7 +3674,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Index(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Index(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3694,7 +3694,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3711,7 +3711,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndexPut<T>(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndexPut<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3728,7 +3728,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3747,7 +3747,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3766,7 +3766,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, object body, Func<IndexQueryString, IndexQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3784,7 +3784,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndexPut<T>(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndexPut<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3802,7 +3802,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3822,7 +3822,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3842,7 +3842,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, string id, object body, Func<IndexQueryString, IndexQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3856,7 +3856,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesAnalyzeGetForAll<T>(Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesAnalyzeGetForAll<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_analyze
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3870,7 +3870,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesAnalyzeGetForAllAsync<T>(Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesAnalyzeGetForAllAsync<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3886,7 +3886,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGetForAll(Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGetForAll(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_analyze
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3902,7 +3902,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetForAllAsync(Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetForAllAsync(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3917,7 +3917,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesAnalyzeGet<T>(string index, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesAnalyzeGet<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_analyze
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3932,7 +3932,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesAnalyzeGetAsync<T>(string index, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesAnalyzeGetAsync<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3949,7 +3949,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGet(string index, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGet(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_analyze
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3966,7 +3966,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetAsync(string index, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetAsync(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3981,7 +3981,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesAnalyzeForAll<T>(object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesAnalyzeForAll<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_analyze
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3996,7 +3996,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesAnalyzeForAllAsync<T>(object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesAnalyzeForAllAsync<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4013,7 +4013,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeForAll(object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeForAll(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_analyze
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4030,7 +4030,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeForAllAsync(object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeForAllAsync(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4046,7 +4046,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesAnalyze<T>(string index, object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesAnalyze<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_analyze
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4062,7 +4062,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesAnalyzeAsync<T>(string index, object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesAnalyzeAsync<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4080,7 +4080,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesAnalyze(string index, object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesAnalyze(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_analyze
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4098,7 +4098,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeAsync(string index, object body, Func<AnalyzeQueryString, AnalyzeQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeAsync(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4112,7 +4112,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesClearCacheForAll<T>(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClearCacheForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_cache/clear
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4126,7 +4126,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesClearCacheForAllAsync<T>(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesClearCacheForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4142,7 +4142,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesClearCacheForAll(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClearCacheForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_cache/clear
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4158,7 +4158,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheForAllAsync(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4173,7 +4173,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesClearCache<T>(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClearCache<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_cache/clear
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4188,7 +4188,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesClearCacheAsync<T>(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesClearCacheAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4205,7 +4205,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesClearCache(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClearCache(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_cache/clear
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4222,7 +4222,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheAsync(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4236,7 +4236,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesClearCacheGetForAll<T>(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClearCacheGetForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cache/clear
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4250,7 +4250,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesClearCacheGetForAllAsync<T>(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesClearCacheGetForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4266,7 +4266,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGetForAll(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGetForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cache/clear
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4282,7 +4282,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetForAllAsync(Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4297,7 +4297,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesClearCacheGet<T>(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClearCacheGet<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_cache/clear
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4312,7 +4312,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesClearCacheGetAsync<T>(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesClearCacheGetAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4329,7 +4329,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGet(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGet(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_cache/clear
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4346,7 +4346,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetAsync(string index, Func<ClearCacheQueryString, ClearCacheQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_close
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4361,7 +4361,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesClose<T>(string index, Func<CloseIndexQueryString, CloseIndexQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClose<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_close
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4376,7 +4376,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesCloseAsync<T>(string index, Func<CloseIndexQueryString, CloseIndexQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesCloseAsync<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_close
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4393,7 +4393,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesClose(string index, Func<CloseIndexQueryString, CloseIndexQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClose(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_close
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4410,7 +4410,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesCloseAsync(string index, Func<CloseIndexQueryString, CloseIndexQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesCloseAsync(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4426,7 +4426,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesCreate<T>(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesCreate<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4442,7 +4442,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesCreateAsync<T>(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesCreateAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4460,7 +4460,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesCreate(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesCreate(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4478,7 +4478,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreateAsync(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreateAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4494,7 +4494,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesCreatePost<T>(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesCreatePost<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4510,7 +4510,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesCreatePostAsync<T>(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesCreatePostAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4528,7 +4528,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesCreatePost(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesCreatePost(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4546,7 +4546,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreatePostAsync(string index, object body, Func<CreateIndexQueryString, CreateIndexQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreatePostAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4561,7 +4561,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesDelete<T>(string index, Func<DeleteIndexQueryString, DeleteIndexQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDelete<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4576,7 +4576,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesDeleteAsync<T>(string index, Func<DeleteIndexQueryString, DeleteIndexQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteAsync<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4593,7 +4593,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesDelete(string index, Func<DeleteIndexQueryString, DeleteIndexQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDelete(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4610,7 +4610,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAsync(string index, Func<DeleteIndexQueryString, DeleteIndexQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAsync(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4626,7 +4626,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesDeleteAlias<T>(string index, string name, Func<IndicesDeleteAliasQueryString, IndicesDeleteAliasQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDeleteAlias<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4642,7 +4642,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesDeleteAliasAsync<T>(string index, string name, Func<IndicesDeleteAliasQueryString, IndicesDeleteAliasQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteAliasAsync<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4660,7 +4660,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesDeleteAlias(string index, string name, Func<IndicesDeleteAliasQueryString, IndicesDeleteAliasQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDeleteAlias(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4678,7 +4678,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAliasAsync(string index, string name, Func<IndicesDeleteAliasQueryString, IndicesDeleteAliasQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAliasAsync(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4694,7 +4694,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesDeleteMapping<T>(string index, string type, Func<DeleteMappingQueryString, DeleteMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDeleteMapping<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4710,7 +4710,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesDeleteMappingAsync<T>(string index, string type, Func<DeleteMappingQueryString, DeleteMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteMappingAsync<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4728,7 +4728,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesDeleteMapping(string index, string type, Func<DeleteMappingQueryString, DeleteMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDeleteMapping(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4746,7 +4746,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteMappingAsync(string index, string type, Func<DeleteMappingQueryString, DeleteMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteMappingAsync(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4761,7 +4761,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesDeleteTemplateForAll<T>(string name, Func<DeleteTemplateQueryString, DeleteTemplateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDeleteTemplateForAll<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4776,7 +4776,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesDeleteTemplateForAllAsync<T>(string name, Func<DeleteTemplateQueryString, DeleteTemplateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteTemplateForAllAsync<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4793,7 +4793,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesDeleteTemplateForAll(string name, Func<DeleteTemplateQueryString, DeleteTemplateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDeleteTemplateForAll(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4810,7 +4810,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteTemplateForAllAsync(string name, Func<DeleteTemplateQueryString, DeleteTemplateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteTemplateForAllAsync(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4826,7 +4826,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesDeleteWarmer<T>(string index, string name, Func<DeleteWarmerQueryString, DeleteWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDeleteWarmer<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4842,7 +4842,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesDeleteWarmerAsync<T>(string index, string name, Func<DeleteWarmerQueryString, DeleteWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteWarmerAsync<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4860,7 +4860,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesDeleteWarmer(string index, string name, Func<DeleteWarmerQueryString, DeleteWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDeleteWarmer(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /{index}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4878,7 +4878,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteWarmerAsync(string index, string name, Func<DeleteWarmerQueryString, DeleteWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteWarmerAsync(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4893,7 +4893,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesExists<T>(string index, Func<IndexExistsQueryString, IndexExistsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExists<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4908,7 +4908,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesExistsAsync<T>(string index, Func<IndexExistsQueryString, IndexExistsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsAsync<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4925,7 +4925,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesExists(string index, Func<IndexExistsQueryString, IndexExistsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExists(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4942,7 +4942,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAsync(string index, Func<IndexExistsQueryString, IndexExistsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAsync(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4957,7 +4957,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesExistsAliasForAll<T>(string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsAliasForAll<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4972,7 +4972,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesExistsAliasForAllAsync<T>(string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsAliasForAllAsync<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4989,7 +4989,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesExistsAliasForAll(string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsAliasForAll(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5006,7 +5006,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasForAllAsync(string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasForAllAsync(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5022,7 +5022,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5038,7 +5038,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5056,7 +5056,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5074,7 +5074,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, string name, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5089,7 +5089,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5104,7 +5104,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5121,7 +5121,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5138,7 +5138,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, Func<IndicesExistsAliasQueryString, IndicesExistsAliasQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5153,7 +5153,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesExistsTemplateForAll<T>(string name, Func<IndicesExistsTemplateQueryString, IndicesExistsTemplateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsTemplateForAll<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5168,7 +5168,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesExistsTemplateForAllAsync<T>(string name, Func<IndicesExistsTemplateQueryString, IndicesExistsTemplateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsTemplateForAllAsync<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5185,7 +5185,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesExistsTemplateForAll(string name, Func<IndicesExistsTemplateQueryString, IndicesExistsTemplateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsTemplateForAll(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5202,7 +5202,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTemplateForAllAsync(string name, Func<IndicesExistsTemplateQueryString, IndicesExistsTemplateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTemplateForAllAsync(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5218,7 +5218,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesExistsType<T>(string index, string type, Func<IndicesExistsTypeQueryString, IndicesExistsTypeQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsType<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5234,7 +5234,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesExistsTypeAsync<T>(string index, string type, Func<IndicesExistsTypeQueryString, IndicesExistsTypeQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsTypeAsync<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5252,7 +5252,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesExistsType(string index, string type, Func<IndicesExistsTypeQueryString, IndicesExistsTypeQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsType(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5270,7 +5270,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTypeAsync(string index, string type, Func<IndicesExistsTypeQueryString, IndicesExistsTypeQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTypeAsync(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5284,7 +5284,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesFlushForAll<T>(Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesFlushForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_flush
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5298,7 +5298,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesFlushForAllAsync<T>(Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesFlushForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5314,7 +5314,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesFlushForAll(Func<FlushQueryString, FlushQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesFlushForAll(Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_flush
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5330,7 +5330,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushForAllAsync(Func<FlushQueryString, FlushQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5345,7 +5345,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesFlush<T>(string index, Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesFlush<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_flush
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5360,7 +5360,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesFlushAsync<T>(string index, Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesFlushAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5377,7 +5377,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesFlush(string index, Func<FlushQueryString, FlushQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesFlush(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_flush
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5394,7 +5394,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushAsync(string index, Func<FlushQueryString, FlushQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5408,7 +5408,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesFlushGetForAll<T>(Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesFlushGetForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_flush
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5422,7 +5422,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesFlushGetForAllAsync<T>(Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesFlushGetForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5438,7 +5438,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesFlushGetForAll(Func<FlushQueryString, FlushQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesFlushGetForAll(Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_flush
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5454,7 +5454,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetForAllAsync(Func<FlushQueryString, FlushQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5469,7 +5469,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesFlushGet<T>(string index, Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesFlushGet<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_flush
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5484,7 +5484,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesFlushGetAsync<T>(string index, Func<FlushQueryString, FlushQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesFlushGetAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5501,7 +5501,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesFlushGet(string index, Func<FlushQueryString, FlushQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesFlushGet(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_flush
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5518,7 +5518,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetAsync(string index, Func<FlushQueryString, FlushQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5532,7 +5532,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetAliasForAll<T>(Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliasForAll<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_alias
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5546,7 +5546,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5562,7 +5562,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_alias
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5578,7 +5578,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5593,7 +5593,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetAliasForAll<T>(string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliasForAll<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5608,7 +5608,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5625,7 +5625,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5642,7 +5642,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5658,7 +5658,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetAlias<T>(string index, string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAlias<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5674,7 +5674,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5692,7 +5692,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5710,7 +5710,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, string name, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5725,7 +5725,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetAlias<T>(string index, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAlias<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_alias
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5740,7 +5740,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5757,7 +5757,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_alias
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5774,7 +5774,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, Func<GetAliasesQueryString, GetAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5788,7 +5788,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_aliases
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5802,7 +5802,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5818,7 +5818,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_aliases
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5834,7 +5834,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5849,7 +5849,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetAliases<T>(string index, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliases<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5864,7 +5864,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5881,7 +5881,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5898,7 +5898,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5914,7 +5914,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetAliases<T>(string index, string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliases<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5930,7 +5930,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5948,7 +5948,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5966,7 +5966,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5981,7 +5981,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_aliases/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5996,7 +5996,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6013,7 +6013,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_aliases/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6030,7 +6030,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(string name, Func<IndicesGetAliasesQueryString, IndicesGetAliasesQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mapping/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6045,7 +6045,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mapping/field/{field}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6060,7 +6060,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mapping/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6077,7 +6077,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mapping/field/{field}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6094,7 +6094,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6110,7 +6110,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/field/{field}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6126,7 +6126,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6144,7 +6144,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/field/{field}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6162,7 +6162,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6178,7 +6178,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}/field/{field}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6194,7 +6194,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6212,7 +6212,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}/field/{field}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6230,7 +6230,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6247,7 +6247,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}/field/{field}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6264,7 +6264,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6283,7 +6283,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}/field/{field}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6302,7 +6302,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string type, string field, Func<IndicesGetFieldMappingQueryString, IndicesGetFieldMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6316,7 +6316,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetMappingForAll<T>(Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetMappingForAll<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6330,7 +6330,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6346,7 +6346,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(Func<GetMappingQueryString, GetMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6362,7 +6362,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(Func<GetMappingQueryString, GetMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6377,7 +6377,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetMapping<T>(string index, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetMapping<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6392,7 +6392,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6409,7 +6409,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, Func<GetMappingQueryString, GetMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6426,7 +6426,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, Func<GetMappingQueryString, GetMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6441,7 +6441,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetMappingForAll<T>(string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetMappingForAll<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6456,7 +6456,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6473,7 +6473,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6490,7 +6490,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6506,7 +6506,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetMapping<T>(string index, string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetMapping<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6522,7 +6522,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6540,7 +6540,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6558,7 +6558,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, string type, Func<GetMappingQueryString, GetMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6572,7 +6572,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6586,7 +6586,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6602,7 +6602,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6618,7 +6618,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6633,7 +6633,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetSettings<T>(string index, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetSettings<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6648,7 +6648,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6665,7 +6665,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6682,7 +6682,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_settings/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6698,7 +6698,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetSettings<T>(string index, string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetSettings<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_settings/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6714,7 +6714,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_settings/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6732,7 +6732,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_settings/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6750,7 +6750,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_settings/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6765,7 +6765,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_settings/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6780,7 +6780,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_settings/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6797,7 +6797,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_settings/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6814,7 +6814,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(string name, Func<GetIndexSettingsQueryString, GetIndexSettingsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_template
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6828,7 +6828,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_template
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6842,7 +6842,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_template
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6858,7 +6858,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_template
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6874,7 +6874,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6889,7 +6889,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(string name, Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6904,7 +6904,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(string name, Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6921,7 +6921,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(string name, Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6938,7 +6938,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(string name, Func<GetTemplateQueryString, GetTemplateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_warmer
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6952,7 +6952,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_warmer
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6966,7 +6966,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_warmer
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6982,7 +6982,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_warmer
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6998,7 +6998,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7013,7 +7013,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7028,7 +7028,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7045,7 +7045,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7062,7 +7062,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7078,7 +7078,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7094,7 +7094,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7112,7 +7112,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7130,7 +7130,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7145,7 +7145,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7160,7 +7160,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7177,7 +7177,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7194,7 +7194,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7211,7 +7211,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string type, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7228,7 +7228,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string type, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7247,7 +7247,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string type, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7266,7 +7266,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string type, string name, Func<GetWarmerQueryString, GetWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_open
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7281,7 +7281,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesOpen<T>(string index, Func<OpenIndexQueryString, OpenIndexQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOpen<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_open
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7296,7 +7296,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesOpenAsync<T>(string index, Func<OpenIndexQueryString, OpenIndexQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOpenAsync<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_open
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7313,7 +7313,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesOpen(string index, Func<OpenIndexQueryString, OpenIndexQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOpen(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_open
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7330,7 +7330,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOpenAsync(string index, Func<OpenIndexQueryString, OpenIndexQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOpenAsync(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7344,7 +7344,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesOptimizeForAll<T>(Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOptimizeForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_optimize
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7358,7 +7358,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesOptimizeForAllAsync<T>(Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOptimizeForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7374,7 +7374,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesOptimizeForAll(Func<OptimizeQueryString, OptimizeQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOptimizeForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_optimize
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7390,7 +7390,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeForAllAsync(Func<OptimizeQueryString, OptimizeQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7405,7 +7405,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesOptimize<T>(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOptimize<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_optimize
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7420,7 +7420,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesOptimizeAsync<T>(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOptimizeAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7437,7 +7437,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesOptimize(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOptimize(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_optimize
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7454,7 +7454,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeAsync(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7468,7 +7468,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesOptimizeGetForAll<T>(Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOptimizeGetForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_optimize
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7482,7 +7482,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesOptimizeGetForAllAsync<T>(Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOptimizeGetForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7498,7 +7498,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGetForAll(Func<OptimizeQueryString, OptimizeQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGetForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_optimize
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7514,7 +7514,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetForAllAsync(Func<OptimizeQueryString, OptimizeQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7529,7 +7529,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesOptimizeGet<T>(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOptimizeGet<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_optimize
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7544,7 +7544,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesOptimizeGetAsync<T>(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOptimizeGetAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7561,7 +7561,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGet(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGet(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_optimize
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7578,7 +7578,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetAsync(string index, Func<OptimizeQueryString, OptimizeQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7595,7 +7595,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutAlias<T>(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutAlias<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7612,7 +7612,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutAliasAsync<T>(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutAliasAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7631,7 +7631,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutAlias(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutAlias(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7650,7 +7650,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasAsync(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7666,7 +7666,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutAliasForAll<T>(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutAliasForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7682,7 +7682,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutAliasForAllAsync<T>(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutAliasForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7700,7 +7700,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutAliasForAll(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutAliasForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7718,7 +7718,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasForAllAsync(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7735,7 +7735,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutAliasPost<T>(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutAliasPost<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7752,7 +7752,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutAliasPostAsync<T>(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutAliasPostAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7771,7 +7771,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPost(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPost(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7790,7 +7790,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostAsync(string index, string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7806,7 +7806,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutAliasPostForAll<T>(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutAliasPostForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7822,7 +7822,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutAliasPostForAllAsync<T>(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutAliasPostForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7840,7 +7840,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPostForAll(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPostForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7858,7 +7858,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostForAllAsync(string name, object body, Func<IndicesPutAliasQueryString, IndicesPutAliasQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7875,7 +7875,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutMapping<T>(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutMapping<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7892,7 +7892,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutMappingAsync<T>(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutMappingAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7911,7 +7911,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutMapping(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutMapping(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7930,7 +7930,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingAsync(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7946,7 +7946,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutMappingForAll<T>(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutMappingForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_mapping/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7962,7 +7962,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutMappingForAllAsync<T>(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutMappingForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7980,7 +7980,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutMappingForAll(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutMappingForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_mapping/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7998,7 +7998,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingForAllAsync(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8015,7 +8015,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutMappingPost<T>(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutMappingPost<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8032,7 +8032,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutMappingPostAsync<T>(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutMappingPostAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8051,7 +8051,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPost(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPost(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8070,7 +8070,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostAsync(string index, string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8086,7 +8086,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutMappingPostForAll<T>(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutMappingPostForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_mapping/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8102,7 +8102,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutMappingPostForAllAsync<T>(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutMappingPostForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8120,7 +8120,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPostForAll(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPostForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_mapping/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8138,7 +8138,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostForAllAsync(string type, object body, Func<PutMappingQueryString, PutMappingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8153,7 +8153,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutSettingsForAll<T>(object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutSettingsForAll<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8168,7 +8168,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutSettingsForAllAsync<T>(object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutSettingsForAllAsync<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8185,7 +8185,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutSettingsForAll(object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutSettingsForAll(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8202,7 +8202,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsForAllAsync(object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsForAllAsync(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8218,7 +8218,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutSettings<T>(string index, object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutSettings<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/_settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8234,7 +8234,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutSettingsAsync<T>(string index, object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutSettingsAsync<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8252,7 +8252,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutSettings(string index, object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutSettings(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/_settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8270,7 +8270,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsAsync(string index, object body, Func<UpdateSettingsQueryString, UpdateSettingsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsAsync(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8286,7 +8286,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutTemplateForAll<T>(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutTemplateForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8302,7 +8302,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutTemplateForAllAsync<T>(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutTemplateForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8320,7 +8320,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutTemplateForAll(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutTemplateForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8338,7 +8338,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplateForAllAsync(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplateForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8354,7 +8354,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutTemplatePostForAll<T>(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutTemplatePostForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8370,7 +8370,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutTemplatePostForAllAsync<T>(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutTemplatePostForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8388,7 +8388,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutTemplatePostForAll(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutTemplatePostForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8406,7 +8406,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplatePostForAllAsync(string name, object body, Func<PutTemplateQueryString, PutTemplateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplatePostForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8422,7 +8422,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutWarmerForAll<T>(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmerForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8438,7 +8438,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutWarmerForAllAsync<T>(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8456,7 +8456,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerForAll(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8474,7 +8474,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerForAllAsync(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8491,7 +8491,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8508,7 +8508,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8527,7 +8527,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8546,7 +8546,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8564,7 +8564,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8582,7 +8582,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8602,7 +8602,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8622,7 +8622,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8638,7 +8638,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutWarmerPostForAll<T>(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmerPostForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8654,7 +8654,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutWarmerPostForAllAsync<T>(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerPostForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8672,7 +8672,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPostForAll(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPostForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8690,7 +8690,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostForAllAsync(string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8707,7 +8707,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8724,7 +8724,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8743,7 +8743,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8762,7 +8762,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8780,7 +8780,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8798,7 +8798,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8818,7 +8818,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8838,7 +8838,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string type, string name, object body, Func<PutWarmerQueryString, PutWarmerQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8852,7 +8852,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesRefreshForAll<T>(Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesRefreshForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_refresh
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8866,7 +8866,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesRefreshForAllAsync<T>(Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesRefreshForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8882,7 +8882,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesRefreshForAll(Func<RefreshQueryString, RefreshQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesRefreshForAll(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_refresh
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8898,7 +8898,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshForAllAsync(Func<RefreshQueryString, RefreshQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8913,7 +8913,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesRefresh<T>(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesRefresh<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_refresh
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8928,7 +8928,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesRefreshAsync<T>(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesRefreshAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8945,7 +8945,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesRefresh(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesRefresh(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_refresh
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8962,7 +8962,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshAsync(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8976,7 +8976,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesRefreshGetForAll<T>(Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesRefreshGetForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_refresh
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8990,7 +8990,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesRefreshGetForAllAsync<T>(Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesRefreshGetForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9006,7 +9006,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesRefreshGetForAll(Func<RefreshQueryString, RefreshQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesRefreshGetForAll(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_refresh
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9022,7 +9022,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetForAllAsync(Func<RefreshQueryString, RefreshQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9037,7 +9037,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesRefreshGet<T>(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesRefreshGet<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_refresh
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9052,7 +9052,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesRefreshGetAsync<T>(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesRefreshGetAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9069,7 +9069,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesRefreshGet(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesRefreshGet(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_refresh
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9086,7 +9086,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetAsync(string index, Func<RefreshQueryString, RefreshQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_segments
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9100,7 +9100,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesSegmentsForAll<T>(Func<SegmentsQueryString, SegmentsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesSegmentsForAll<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_segments
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9114,7 +9114,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesSegmentsForAllAsync<T>(Func<SegmentsQueryString, SegmentsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesSegmentsForAllAsync<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_segments
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9130,7 +9130,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesSegmentsForAll(Func<SegmentsQueryString, SegmentsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesSegmentsForAll(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_segments
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9146,7 +9146,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsForAllAsync(Func<SegmentsQueryString, SegmentsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsForAllAsync(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_segments
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9161,7 +9161,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesSegments<T>(string index, Func<SegmentsQueryString, SegmentsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesSegments<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_segments
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9176,7 +9176,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesSegmentsAsync<T>(string index, Func<SegmentsQueryString, SegmentsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesSegmentsAsync<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_segments
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9193,7 +9193,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesSegments(string index, Func<SegmentsQueryString, SegmentsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesSegments(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_segments
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9210,7 +9210,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsAsync(string index, Func<SegmentsQueryString, SegmentsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsAsync(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_gateway/snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9224,7 +9224,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesSnapshotIndexForAll<T>(Func<SnapshotQueryString, SnapshotQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesSnapshotIndexForAll<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_gateway/snapshot
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9238,7 +9238,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesSnapshotIndexForAllAsync<T>(Func<SnapshotQueryString, SnapshotQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesSnapshotIndexForAllAsync<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_gateway/snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9254,7 +9254,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndexForAll(Func<SnapshotQueryString, SnapshotQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndexForAll(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_gateway/snapshot
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9270,7 +9270,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexForAllAsync(Func<SnapshotQueryString, SnapshotQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexForAllAsync(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_gateway/snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9285,7 +9285,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesSnapshotIndex<T>(string index, Func<SnapshotQueryString, SnapshotQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesSnapshotIndex<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_gateway/snapshot
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9300,7 +9300,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesSnapshotIndexAsync<T>(string index, Func<SnapshotQueryString, SnapshotQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesSnapshotIndexAsync<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_gateway/snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9317,7 +9317,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndex(string index, Func<SnapshotQueryString, SnapshotQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndex(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_gateway/snapshot
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9334,7 +9334,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexAsync(string index, Func<SnapshotQueryString, SnapshotQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexAsync(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9348,7 +9348,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesStatsForAll<T>(Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStatsForAll<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9362,7 +9362,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9378,7 +9378,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9394,7 +9394,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9409,7 +9409,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesStatsForAll<T>(string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStatsForAll<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_stats/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9424,7 +9424,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9441,7 +9441,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_stats/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9458,7 +9458,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9473,7 +9473,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesStats<T>(string index, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStats<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9488,7 +9488,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9505,7 +9505,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9522,7 +9522,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9538,7 +9538,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_stats/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9554,7 +9554,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9572,7 +9572,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_stats/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9590,7 +9590,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, string metric, Func<IndicesStatsQueryString, IndicesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_status
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9604,7 +9604,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesStatusForAll<T>(Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStatusForAll<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_status
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9618,7 +9618,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesStatusForAllAsync<T>(Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatusForAllAsync<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_status
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9634,7 +9634,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesStatusForAll(Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStatusForAll(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_status
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9650,7 +9650,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusForAllAsync(Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusForAllAsync(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_status
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9665,7 +9665,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesStatus<T>(string index, Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStatus<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_status
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9680,7 +9680,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesStatusAsync<T>(string index, Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatusAsync<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_status
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9697,7 +9697,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesStatus(string index, Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStatus(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_status
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9714,7 +9714,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusAsync(string index, Func<IndicesStatusQueryString, IndicesStatusQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusAsync(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9729,7 +9729,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesUpdateAliasesForAll<T>(object body, Func<AliasQueryString, AliasQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesUpdateAliasesForAll<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_aliases
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9744,7 +9744,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesUpdateAliasesForAllAsync<T>(object body, Func<AliasQueryString, AliasQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesUpdateAliasesForAllAsync<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9761,7 +9761,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesUpdateAliasesForAll(object body, Func<AliasQueryString, AliasQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesUpdateAliasesForAll(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_aliases
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9778,7 +9778,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesUpdateAliasesForAllAsync(object body, Func<AliasQueryString, AliasQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesUpdateAliasesForAllAsync(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9792,7 +9792,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesValidateQueryGetForAll<T>(Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQueryGetForAll<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9806,7 +9806,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesValidateQueryGetForAllAsync<T>(Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryGetForAllAsync<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9822,7 +9822,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGetForAll(Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGetForAll(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9838,7 +9838,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetForAllAsync(Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetForAllAsync(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9853,7 +9853,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9868,7 +9868,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9885,7 +9885,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9902,7 +9902,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9918,7 +9918,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, string type, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9934,7 +9934,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, string type, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9952,7 +9952,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, string type, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9970,7 +9970,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, string type, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9985,7 +9985,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesValidateQueryForAll<T>(object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQueryForAll<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10000,7 +10000,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesValidateQueryForAllAsync<T>(object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryForAllAsync<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10017,7 +10017,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryForAll(object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryForAll(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10034,7 +10034,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryForAllAsync(object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryForAllAsync(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10050,7 +10050,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10066,7 +10066,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10084,7 +10084,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10102,7 +10102,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10119,7 +10119,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, string type, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10136,7 +10136,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, string type, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10155,7 +10155,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, string type, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10174,7 +10174,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, string type, object body, Func<ValidateQueryQueryString, ValidateQueryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10188,7 +10188,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Info<T>(Func<InfoQueryString, InfoQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Info<T>(Func<InfoRequestParameters, InfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10202,7 +10202,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> InfoAsync<T>(Func<InfoQueryString, InfoQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> InfoAsync<T>(Func<InfoRequestParameters, InfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10218,7 +10218,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Info(Func<InfoQueryString, InfoQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Info(Func<InfoRequestParameters, InfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10234,7 +10234,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> InfoAsync(Func<InfoQueryString, InfoQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> InfoAsync(Func<InfoRequestParameters, InfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10248,7 +10248,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MgetGet<T>(Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MgetGet<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10262,7 +10262,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MgetGetAsync<T>(Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetGetAsync<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10278,7 +10278,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MgetGet(Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MgetGet(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10294,7 +10294,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10309,7 +10309,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MgetGet<T>(string index, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MgetGet<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10324,7 +10324,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10341,7 +10341,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MgetGet(string index, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MgetGet(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10358,7 +10358,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10374,7 +10374,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MgetGet<T>(string index, string type, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MgetGet<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10390,7 +10390,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, string type, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10408,7 +10408,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MgetGet(string index, string type, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MgetGet(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10426,7 +10426,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, string type, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10441,7 +10441,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mget<T>(object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mget<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10456,7 +10456,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MgetAsync<T>(object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetAsync<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10473,7 +10473,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mget(object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mget(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10490,7 +10490,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10506,7 +10506,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mget<T>(string index, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mget<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10522,7 +10522,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10540,7 +10540,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mget(string index, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mget(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10558,7 +10558,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10575,7 +10575,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mget<T>(string index, string type, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mget<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10592,7 +10592,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, string type, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10611,7 +10611,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mget(string index, string type, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mget(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10630,7 +10630,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, string type, object body, Func<MultiGetQueryString, MultiGetQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10647,7 +10647,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MltGet<T>(string index, string type, string id, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MltGet<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10664,7 +10664,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MltGetAsync<T>(string index, string type, string id, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MltGetAsync<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10683,7 +10683,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MltGet(string index, string type, string id, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MltGet(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10702,7 +10702,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MltGetAsync(string index, string type, string id, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MltGetAsync(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10720,7 +10720,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mlt<T>(string index, string type, string id, object body, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mlt<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10738,7 +10738,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MltAsync<T>(string index, string type, string id, object body, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MltAsync<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10758,7 +10758,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mlt(string index, string type, string id, object body, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mlt(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10778,7 +10778,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MltAsync(string index, string type, string id, object body, Func<MoreLikeThisQueryString, MoreLikeThisQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MltAsync(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10792,7 +10792,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MpercolateGet<T>(Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MpercolateGet<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10806,7 +10806,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10822,7 +10822,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MpercolateGet(Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MpercolateGet(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10838,7 +10838,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10853,7 +10853,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MpercolateGet<T>(string index, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MpercolateGet<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10868,7 +10868,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10885,7 +10885,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10902,7 +10902,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10918,7 +10918,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MpercolateGet<T>(string index, string type, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MpercolateGet<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10934,7 +10934,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string type, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10952,7 +10952,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, string type, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10970,7 +10970,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, string type, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10985,7 +10985,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mpercolate<T>(object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mpercolate<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11000,7 +11000,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MpercolateAsync<T>(object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateAsync<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11017,7 +11017,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mpercolate(object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mpercolate(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11034,7 +11034,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11050,7 +11050,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mpercolate<T>(string index, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mpercolate<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11066,7 +11066,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11084,7 +11084,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11102,7 +11102,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11119,7 +11119,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11136,7 +11136,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, string type, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11155,7 +11155,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, string type, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11174,7 +11174,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, string type, object body, Func<MpercolateQueryString, MpercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11188,7 +11188,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MsearchGet<T>(Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MsearchGet<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11202,7 +11202,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11218,7 +11218,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MsearchGet(Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MsearchGet(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11234,7 +11234,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11249,7 +11249,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MsearchGet<T>(string index, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MsearchGet<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11264,7 +11264,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11281,7 +11281,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11298,7 +11298,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11314,7 +11314,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11330,7 +11330,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, string type, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11348,7 +11348,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, string type, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11366,7 +11366,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, string type, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11381,7 +11381,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Msearch<T>(object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Msearch<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11396,7 +11396,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MsearchAsync<T>(object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchAsync<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11413,7 +11413,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Msearch(object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Msearch(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11430,7 +11430,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11446,7 +11446,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Msearch<T>(string index, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Msearch<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11462,7 +11462,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11480,7 +11480,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Msearch(string index, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Msearch(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11498,7 +11498,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11515,7 +11515,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Msearch<T>(string index, string type, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Msearch<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11532,7 +11532,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, string type, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11551,7 +11551,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Msearch(string index, string type, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Msearch(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11570,7 +11570,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, string type, object body, Func<MultiSearchQueryString, MultiSearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11584,7 +11584,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MtermvectorsGet<T>(Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MtermvectorsGet<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11598,7 +11598,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11614,7 +11614,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11630,7 +11630,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11645,7 +11645,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MtermvectorsGet<T>(string index, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MtermvectorsGet<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11660,7 +11660,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11677,7 +11677,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11694,7 +11694,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11710,7 +11710,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11726,7 +11726,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, string type, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11744,7 +11744,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, string type, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11762,7 +11762,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, string type, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11777,7 +11777,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mtermvectors<T>(object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mtermvectors<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11792,7 +11792,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11809,7 +11809,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mtermvectors(object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mtermvectors(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11826,7 +11826,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11842,7 +11842,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mtermvectors<T>(string index, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mtermvectors<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11858,7 +11858,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11876,7 +11876,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11894,7 +11894,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11911,7 +11911,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11928,7 +11928,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, string type, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11947,7 +11947,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, string type, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11966,7 +11966,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, string type, object body, Func<MtermvectorsQueryString, MtermvectorsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/hotthreads
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11980,7 +11980,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesHotThreadsForAll<T>(Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesHotThreadsForAll<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/hotthreads
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11994,7 +11994,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesHotThreadsForAllAsync<T>(Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesHotThreadsForAllAsync<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/hotthreads
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12010,7 +12010,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesHotThreadsForAll(Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesHotThreadsForAll(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/hotthreads
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12026,7 +12026,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsForAllAsync(Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsForAllAsync(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/{node_id}/hotthreads
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12041,7 +12041,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesHotThreads<T>(string node_id, Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesHotThreads<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/{node_id}/hotthreads
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12056,7 +12056,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesHotThreadsAsync<T>(string node_id, Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesHotThreadsAsync<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/{node_id}/hotthreads
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12073,7 +12073,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesHotThreads(string node_id, Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesHotThreads(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/{node_id}/hotthreads
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12090,7 +12090,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsAsync(string node_id, Func<NodesHotThreadsQueryString, NodesHotThreadsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsAsync(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12104,7 +12104,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesInfoForAll<T>(Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesInfoForAll<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12118,7 +12118,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12134,7 +12134,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12150,7 +12150,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12165,7 +12165,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesInfo<T>(string node_id, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesInfo<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12180,7 +12180,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12197,7 +12197,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12214,7 +12214,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12229,7 +12229,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesInfoForAll<T>(string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesInfoForAll<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12244,7 +12244,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12261,7 +12261,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12278,7 +12278,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12294,7 +12294,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12310,7 +12310,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12328,7 +12328,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12346,7 +12346,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, string metric, Func<NodesInfoQueryString, NodesInfoQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_shutdown
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12360,7 +12360,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesShutdownForAll<T>(Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesShutdownForAll<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_shutdown
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12374,7 +12374,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesShutdownForAllAsync<T>(Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesShutdownForAllAsync<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_shutdown
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12390,7 +12390,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesShutdownForAll(Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesShutdownForAll(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_shutdown
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12406,7 +12406,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownForAllAsync(Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownForAllAsync(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_cluster/nodes/{node_id}/_shutdown
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12421,7 +12421,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesShutdown<T>(string node_id, Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesShutdown<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_cluster/nodes/{node_id}/_shutdown
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12436,7 +12436,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesShutdownAsync<T>(string node_id, Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesShutdownAsync<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_cluster/nodes/{node_id}/_shutdown
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12453,7 +12453,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesShutdown(string node_id, Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesShutdown(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_cluster/nodes/{node_id}/_shutdown
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12470,7 +12470,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownAsync(string node_id, Func<NodesShutdownQueryString, NodesShutdownQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownAsync(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12484,7 +12484,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesStatsForAll<T>(Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStatsForAll<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12498,7 +12498,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12514,7 +12514,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12530,7 +12530,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12545,7 +12545,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesStats<T>(string node_id, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStats<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12560,7 +12560,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12577,7 +12577,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12594,7 +12594,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12609,7 +12609,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12624,7 +12624,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12641,7 +12641,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12658,7 +12658,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12674,7 +12674,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12690,7 +12690,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12708,7 +12708,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12726,7 +12726,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}/{index_metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12742,7 +12742,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}/{index_metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12758,7 +12758,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}/{index_metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12776,7 +12776,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}/{index_metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12794,7 +12794,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12811,7 +12811,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12828,7 +12828,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12847,7 +12847,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12866,7 +12866,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, string index_metric, Func<NodesStatsQueryString, NodesStatsQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12882,7 +12882,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> PercolateGet<T>(string index, string type, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> PercolateGet<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12898,7 +12898,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12916,7 +12916,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, Func<PercolateQueryString, PercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12934,7 +12934,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, Func<PercolateQueryString, PercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12951,7 +12951,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> PercolateGet<T>(string index, string type, string id, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> PercolateGet<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12968,7 +12968,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, string id, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12987,7 +12987,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, string id, Func<PercolateQueryString, PercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13006,7 +13006,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, string id, Func<PercolateQueryString, PercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13023,7 +13023,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Percolate<T>(string index, string type, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Percolate<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13040,7 +13040,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13059,7 +13059,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13078,7 +13078,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13096,7 +13096,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Percolate<T>(string index, string type, string id, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Percolate<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13114,7 +13114,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, string id, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13134,7 +13134,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, string id, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13154,7 +13154,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, string id, object body, Func<PercolateQueryString, PercolateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13168,7 +13168,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Ping<T>(Func<PingQueryString, PingQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Ping<T>(Func<PingRequestParameters, PingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13182,7 +13182,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> PingAsync<T>(Func<PingQueryString, PingQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PingAsync<T>(Func<PingRequestParameters, PingRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a HEAD on /
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13198,7 +13198,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Ping(Func<PingQueryString, PingQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Ping(Func<PingRequestParameters, PingRequestParameters> queryString = null);
 		
 		///<summary>Represents a HEAD on /
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13214,7 +13214,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingQueryString, PingQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingRequestParameters, PingRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13228,7 +13228,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ScrollGet<T>(Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ScrollGet<T>(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13242,7 +13242,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13258,7 +13258,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ScrollGet(Func<ScrollQueryString, ScrollQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ScrollGet(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13274,7 +13274,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(Func<ScrollQueryString, ScrollQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13289,7 +13289,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> ScrollGet<T>(string scroll_id, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ScrollGet<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_search/scroll/{scroll_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13304,7 +13304,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(string scroll_id, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13321,7 +13321,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> ScrollGet(string scroll_id, Func<ScrollQueryString, ScrollQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ScrollGet(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_search/scroll/{scroll_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13338,7 +13338,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(string scroll_id, Func<ScrollQueryString, ScrollQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13353,7 +13353,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Scroll<T>(object body, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Scroll<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_search/scroll
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13368,7 +13368,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ScrollAsync<T>(object body, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ScrollAsync<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13385,7 +13385,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Scroll(object body, Func<ScrollQueryString, ScrollQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Scroll(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_search/scroll
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13402,7 +13402,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(object body, Func<ScrollQueryString, ScrollQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13418,7 +13418,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Scroll<T>(string scroll_id, object body, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Scroll<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_search/scroll/{scroll_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13434,7 +13434,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> ScrollAsync<T>(string scroll_id, object body, Func<ScrollQueryString, ScrollQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ScrollAsync<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13452,7 +13452,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Scroll(string scroll_id, object body, Func<ScrollQueryString, ScrollQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Scroll(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_search/scroll/{scroll_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13470,7 +13470,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(string scroll_id, object body, Func<ScrollQueryString, ScrollQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13484,7 +13484,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SearchGet<T>(Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SearchGet<T>(Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13498,7 +13498,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SearchGetAsync<T>(Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchGetAsync<T>(Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13514,7 +13514,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SearchGet(Func<SearchQueryString, SearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SearchGet(Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13530,7 +13530,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(Func<SearchQueryString, SearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13545,7 +13545,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SearchGet<T>(string index, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SearchGet<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13560,7 +13560,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13577,7 +13577,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SearchGet(string index, Func<SearchQueryString, SearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SearchGet(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13594,7 +13594,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, Func<SearchQueryString, SearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13610,7 +13610,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SearchGet<T>(string index, string type, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SearchGet<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13626,7 +13626,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, string type, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13644,7 +13644,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SearchGet(string index, string type, Func<SearchQueryString, SearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SearchGet(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13662,7 +13662,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, string type, Func<SearchQueryString, SearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13677,7 +13677,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Search<T>(object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Search<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13692,7 +13692,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SearchAsync<T>(object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchAsync<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13709,7 +13709,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Search(object body, Func<SearchQueryString, SearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Search(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13726,7 +13726,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(object body, Func<SearchQueryString, SearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13742,7 +13742,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Search<T>(string index, object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Search<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13758,7 +13758,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13776,7 +13776,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Search(string index, object body, Func<SearchQueryString, SearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Search(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13794,7 +13794,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, object body, Func<SearchQueryString, SearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13811,7 +13811,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Search<T>(string index, string type, object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Search<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13828,7 +13828,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, string type, object body, Func<SearchQueryString, SearchQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13847,7 +13847,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Search(string index, string type, object body, Func<SearchQueryString, SearchQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Search(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13866,7 +13866,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, string type, object body, Func<SearchQueryString, SearchQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13883,7 +13883,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotCreate<T>(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotCreate<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13900,7 +13900,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotCreateAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotCreateAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13919,7 +13919,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotCreate(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotCreate(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13938,7 +13938,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateAsync(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13955,7 +13955,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotCreatePost<T>(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotCreatePost<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13972,7 +13972,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotCreatePostAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotCreatePostAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13991,7 +13991,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotCreatePost(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotCreatePost(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14010,7 +14010,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreatePostAsync(string repository, string snapshot, object body, Func<SnapshotCreateQueryString, SnapshotCreateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreatePostAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14026,7 +14026,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotCreateRepository<T>(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotCreateRepository<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14042,7 +14042,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14060,7 +14060,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepository(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepository(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14078,7 +14078,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryAsync(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14094,7 +14094,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotCreateRepositoryPost<T>(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotCreateRepositoryPost<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14110,7 +14110,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryPostAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryPostAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14128,7 +14128,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepositoryPost(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepositoryPost(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14146,7 +14146,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryPostAsync(string repository, object body, Func<SnapshotCreateRepositoryQueryString, SnapshotCreateRepositoryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryPostAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14162,7 +14162,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotDelete<T>(string repository, string snapshot, Func<SnapshotDeleteQueryString, SnapshotDeleteQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotDelete<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14178,7 +14178,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotDeleteAsync<T>(string repository, string snapshot, Func<SnapshotDeleteQueryString, SnapshotDeleteQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotDeleteAsync<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14196,7 +14196,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotDelete(string repository, string snapshot, Func<SnapshotDeleteQueryString, SnapshotDeleteQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotDelete(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14214,7 +14214,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteAsync(string repository, string snapshot, Func<SnapshotDeleteQueryString, SnapshotDeleteQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteAsync(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14229,7 +14229,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotDeleteRepository<T>(string repository, Func<SnapshotDeleteRepositoryQueryString, SnapshotDeleteRepositoryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotDeleteRepository<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14244,7 +14244,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryAsync<T>(string repository, Func<SnapshotDeleteRepositoryQueryString, SnapshotDeleteRepositoryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryAsync<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14261,7 +14261,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotDeleteRepository(string repository, Func<SnapshotDeleteRepositoryQueryString, SnapshotDeleteRepositoryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotDeleteRepository(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14278,7 +14278,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteRepositoryAsync(string repository, Func<SnapshotDeleteRepositoryQueryString, SnapshotDeleteRepositoryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteRepositoryAsync(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14294,7 +14294,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotGet<T>(string repository, string snapshot, Func<SnapshotGetQueryString, SnapshotGetQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotGet<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14310,7 +14310,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotGetAsync<T>(string repository, string snapshot, Func<SnapshotGetQueryString, SnapshotGetQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotGetAsync<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14328,7 +14328,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotGet(string repository, string snapshot, Func<SnapshotGetQueryString, SnapshotGetQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotGet(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14346,7 +14346,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetAsync(string repository, string snapshot, Func<SnapshotGetQueryString, SnapshotGetQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetAsync(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14360,7 +14360,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotGetRepository<T>(Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotGetRepository<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_snapshot
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14374,7 +14374,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14390,7 +14390,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_snapshot
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14406,7 +14406,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14421,7 +14421,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotGetRepository<T>(string repository, Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotGetRepository<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14436,7 +14436,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(string repository, Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14453,7 +14453,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(string repository, Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14470,7 +14470,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(string repository, Func<SnapshotGetRepositoryQueryString, SnapshotGetRepositoryQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}/_restore
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14487,7 +14487,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SnapshotRestore<T>(string repository, string snapshot, object body, Func<SnapshotRestoreQueryString, SnapshotRestoreQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotRestore<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}/_restore
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14504,7 +14504,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SnapshotRestoreAsync<T>(string repository, string snapshot, object body, Func<SnapshotRestoreQueryString, SnapshotRestoreQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotRestoreAsync<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}/_restore
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14523,7 +14523,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SnapshotRestore(string repository, string snapshot, object body, Func<SnapshotRestoreQueryString, SnapshotRestoreQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotRestore(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}/_restore
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14542,7 +14542,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotRestoreAsync(string repository, string snapshot, object body, Func<SnapshotRestoreQueryString, SnapshotRestoreQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotRestoreAsync(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14557,7 +14557,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Suggest<T>(object body, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Suggest<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_suggest
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14572,7 +14572,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SuggestAsync<T>(object body, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SuggestAsync<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14589,7 +14589,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Suggest(object body, Func<SuggestQueryString, SuggestQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Suggest(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /_suggest
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14606,7 +14606,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(object body, Func<SuggestQueryString, SuggestQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14622,7 +14622,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Suggest<T>(string index, object body, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Suggest<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_suggest
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14638,7 +14638,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SuggestAsync<T>(string index, object body, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SuggestAsync<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14656,7 +14656,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Suggest(string index, object body, Func<SuggestQueryString, SuggestQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Suggest(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/_suggest
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14674,7 +14674,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(string index, object body, Func<SuggestQueryString, SuggestQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14688,7 +14688,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SuggestGet<T>(Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SuggestGet<T>(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_suggest
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14702,7 +14702,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14718,7 +14718,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SuggestGet(Func<SuggestQueryString, SuggestQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SuggestGet(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /_suggest
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14734,7 +14734,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(Func<SuggestQueryString, SuggestQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14749,7 +14749,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> SuggestGet<T>(string index, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SuggestGet<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_suggest
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14764,7 +14764,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(string index, Func<SuggestQueryString, SuggestQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14781,7 +14781,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> SuggestGet(string index, Func<SuggestQueryString, SuggestQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SuggestGet(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/_suggest
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14798,7 +14798,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(string index, Func<SuggestQueryString, SuggestQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14815,7 +14815,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, string id, Func<TermvectorQueryString, TermvectorQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14832,7 +14832,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> TermvectorGetAsync<T>(string index, string type, string id, Func<TermvectorQueryString, TermvectorQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> TermvectorGetAsync<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14851,7 +14851,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, string type, string id, Func<TermvectorQueryString, TermvectorQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14870,7 +14870,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> TermvectorGetAsync(string index, string type, string id, Func<TermvectorQueryString, TermvectorQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> TermvectorGetAsync(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14888,7 +14888,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Termvector<T>(string index, string type, string id, object body, Func<TermvectorQueryString, TermvectorQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Termvector<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14906,7 +14906,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> TermvectorAsync<T>(string index, string type, string id, object body, Func<TermvectorQueryString, TermvectorQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> TermvectorAsync<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14926,7 +14926,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Termvector(string index, string type, string id, object body, Func<TermvectorQueryString, TermvectorQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Termvector(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14946,7 +14946,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string index, string type, string id, object body, Func<TermvectorQueryString, TermvectorQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_update
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14964,7 +14964,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		ElasticsearchResponse<T> Update<T>(string index, string type, string id, object body, Func<UpdateQueryString, UpdateQueryString> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Update<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_update
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14982,7 +14982,7 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<T>> UpdateAsync<T>(string index, string type, string id, object body, Func<UpdateQueryString, UpdateQueryString> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> UpdateAsync<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null, object deserializationState = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_update
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -15002,7 +15002,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> Update(string index, string type, string id, object body, Func<UpdateQueryString, UpdateQueryString> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Update(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_update
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -15022,7 +15022,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> UpdateAsync(string index, string type, string id, object body, Func<UpdateQueryString, UpdateQueryString> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> UpdateAsync(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null);
 		
 	}
 }
\ No newline at end of file
diff --git a/src/Nest/DSL/AliasDescriptor.cs b/src/Nest/DSL/AliasDescriptor.cs
index 7a06b48caf3..60331619371 100644
--- a/src/Nest/DSL/AliasDescriptor.cs
+++ b/src/Nest/DSL/AliasDescriptor.cs
@@ -14,7 +14,7 @@ namespace Nest
 {
 	[DescriptorFor("IndicesUpdateAliases")]
 	public partial class AliasDescriptor : 
-		 IPathInfo<AliasQueryString>
+		 IPathInfo<AliasRequestParameters>
 	{
 		public AliasDescriptor()
 		{
@@ -41,9 +41,9 @@ public AliasDescriptor Remove(Func<AliasRemoveDescriptor, AliasRemoveDescriptor>
 			return this;
 		}
 
-		ElasticsearchPathInfo<AliasQueryString> IPathInfo<AliasQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<AliasRequestParameters> IPathInfo<AliasRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = new ElasticsearchPathInfo<AliasQueryString>();
+			var pathInfo = new ElasticsearchPathInfo<AliasRequestParameters>();
 			pathInfo.QueryString = this._QueryString;
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 
diff --git a/src/Nest/DSL/AnalyzeDescriptor.cs b/src/Nest/DSL/AnalyzeDescriptor.cs
index d956da21e4b..02be27b603c 100644
--- a/src/Nest/DSL/AnalyzeDescriptor.cs
+++ b/src/Nest/DSL/AnalyzeDescriptor.cs
@@ -13,13 +13,13 @@ namespace Nest
 {
 	[DescriptorFor("IndicesAnalyze")]
 	public partial class AnalyzeDescriptor : 
-		IndicesOptionalPathDescriptor<AnalyzeDescriptor, AnalyzeQueryString>
-		, IPathInfo<AnalyzeQueryString>
+		IndicesOptionalPathDescriptor<AnalyzeDescriptor, AnalyzeRequestParameters>
+		, IPathInfo<AnalyzeRequestParameters>
 	{
 
-		ElasticsearchPathInfo<AnalyzeQueryString> IPathInfo<AnalyzeQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<AnalyzeRequestParameters> IPathInfo<AnalyzeRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<AnalyzeQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<AnalyzeRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/BulkDescriptor.cs b/src/Nest/DSL/BulkDescriptor.cs
index 0f5ae1bead6..0ff70aa331b 100644
--- a/src/Nest/DSL/BulkDescriptor.cs
+++ b/src/Nest/DSL/BulkDescriptor.cs
@@ -15,8 +15,8 @@ namespace Nest
 {
 	
 	public partial class BulkDescriptor :
-		FixedIndexTypePathDescriptor<BulkDescriptor, BulkQueryString>
-		, IPathInfo<BulkQueryString>
+		FixedIndexTypePathDescriptor<BulkDescriptor, BulkRequestParameters>
+		, IPathInfo<BulkRequestParameters>
 	{
 		internal IList<BaseBulkOperation> _Operations = new SynchronizedCollection<BaseBulkOperation>();
 
@@ -128,9 +128,9 @@ public BulkDescriptor Update<T, K>(Func<BulkUpdateDescriptor<T, K>, BulkUpdateDe
 			return this;
 		}
 
-		ElasticsearchPathInfo<BulkQueryString> IPathInfo<BulkQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<BulkRequestParameters> IPathInfo<BulkRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = this.ToPathInfo<BulkQueryString>(settings, this._QueryString);
+			var pathInfo = this.ToPathInfo<BulkRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			return pathInfo;
 		}
diff --git a/src/Nest/DSL/ClearCacheDescriptor.cs b/src/Nest/DSL/ClearCacheDescriptor.cs
index aa2263283d1..03822b8c01f 100644
--- a/src/Nest/DSL/ClearCacheDescriptor.cs
+++ b/src/Nest/DSL/ClearCacheDescriptor.cs
@@ -13,12 +13,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesClearCache")]
 	public partial class ClearCacheDescriptor : 
-		IndicesOptionalPathDescriptor<ClearCacheDescriptor, ClearCacheQueryString>
-		, IPathInfo<ClearCacheQueryString>
+		IndicesOptionalPathDescriptor<ClearCacheDescriptor, ClearCacheRequestParameters>
+		, IPathInfo<ClearCacheRequestParameters>
 	{
-		ElasticsearchPathInfo<ClearCacheQueryString> IPathInfo<ClearCacheQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<ClearCacheRequestParameters> IPathInfo<ClearCacheRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<ClearCacheQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<ClearCacheRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/CloseIndexDescriptor.cs b/src/Nest/DSL/CloseIndexDescriptor.cs
index 49556b58696..c42b28d42d7 100644
--- a/src/Nest/DSL/CloseIndexDescriptor.cs
+++ b/src/Nest/DSL/CloseIndexDescriptor.cs
@@ -13,12 +13,12 @@
 namespace Nest
 {
 	[DescriptorFor("IndicesClose")]
-	public partial class CloseIndexDescriptor : IndexPathDescriptorBase<CloseIndexDescriptor, CloseIndexQueryString>
-		, IPathInfo<CloseIndexQueryString>
+	public partial class CloseIndexDescriptor : IndexPathDescriptorBase<CloseIndexDescriptor, CloseIndexRequestParameters>
+		, IPathInfo<CloseIndexRequestParameters>
 	{
-		ElasticsearchPathInfo<CloseIndexQueryString> IPathInfo<CloseIndexQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<CloseIndexRequestParameters> IPathInfo<CloseIndexRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<CloseIndexQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<CloseIndexRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/ClusterHealthDescriptor.cs b/src/Nest/DSL/ClusterHealthDescriptor.cs
index dad03698f8c..3641e17cba1 100644
--- a/src/Nest/DSL/ClusterHealthDescriptor.cs
+++ b/src/Nest/DSL/ClusterHealthDescriptor.cs
@@ -13,12 +13,12 @@
 namespace Nest
 {
 	public partial class ClusterHealthDescriptor : 
-		IndicesOptionalPathDescriptor<ClusterHealthDescriptor, ClusterHealthQueryString>
-		, IPathInfo<ClusterHealthQueryString>
+		IndicesOptionalPathDescriptor<ClusterHealthDescriptor, ClusterHealthRequestParameters>
+		, IPathInfo<ClusterHealthRequestParameters>
 	{
-		ElasticsearchPathInfo<ClusterHealthQueryString> IPathInfo<ClusterHealthQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<ClusterHealthRequestParameters> IPathInfo<ClusterHealthRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<ClusterHealthQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<ClusterHealthRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 			
 			return pathInfo;
diff --git a/src/Nest/DSL/ClusterStateDescriptor.cs b/src/Nest/DSL/ClusterStateDescriptor.cs
index ed48d38fc84..822b3bae42d 100644
--- a/src/Nest/DSL/ClusterStateDescriptor.cs
+++ b/src/Nest/DSL/ClusterStateDescriptor.cs
@@ -13,8 +13,8 @@
 namespace Nest
 {
 	public partial class ClusterStateDescriptor : 
-		IndicesOptionalPathDescriptor<ClusterStateDescriptor, ClusterStateQueryString>
-		, IPathInfo<ClusterStateQueryString>
+		IndicesOptionalPathDescriptor<ClusterStateDescriptor, ClusterStateRequestParameters>
+		, IPathInfo<ClusterStateRequestParameters>
 	{
 		
 		private IEnumerable<ClusterStateMetric> _Metrics { get; set; }
@@ -23,9 +23,9 @@ public ClusterStateDescriptor Metrics(params ClusterStateMetric[] metrics)
 			this._Metrics = metrics;
 			return this;
 		}
-		ElasticsearchPathInfo<ClusterStateQueryString> IPathInfo<ClusterStateQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<ClusterStateRequestParameters> IPathInfo<ClusterStateRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<ClusterStateQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<ClusterStateRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 			if (this._Metrics != null)
 				pathInfo.Metric = this._Metrics.Cast<Enum>().GetStringValue();
diff --git a/src/Nest/DSL/CountDescriptor.cs b/src/Nest/DSL/CountDescriptor.cs
index 5f212b47a55..b9b44369454 100644
--- a/src/Nest/DSL/CountDescriptor.cs
+++ b/src/Nest/DSL/CountDescriptor.cs
@@ -7,8 +7,8 @@ namespace Nest
 {
 	[DescriptorFor("Count")]
 	public partial class CountDescriptor<T> 
-		:	QueryPathDescriptorBase<CountDescriptor<T>, T, CountQueryString>
-		, IPathInfo<CountQueryString> 
+		:	QueryPathDescriptorBase<CountDescriptor<T>, T, CountRequestParameters>
+		, IPathInfo<CountRequestParameters> 
 		where T : class
 	{
 		[JsonProperty("query")]
@@ -20,9 +20,9 @@ public CountDescriptor<T> Query(Func<QueryDescriptor<T>, BaseQuery> querySelecto
 			return this;
 		}
 
-		ElasticsearchPathInfo<CountQueryString> IPathInfo<CountQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<CountRequestParameters> IPathInfo<CountRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<CountQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<CountRequestParameters>(settings, this._QueryString);
 			var qs = this._QueryString;
 			pathInfo.HttpMethod = !qs._source.IsNullOrEmpty() 
 				? PathInfoHttpMethod.GET
diff --git a/src/Nest/DSL/CreateIndexDescriptor.cs b/src/Nest/DSL/CreateIndexDescriptor.cs
index f94320e59fa..d1ed8be995f 100644
--- a/src/Nest/DSL/CreateIndexDescriptor.cs
+++ b/src/Nest/DSL/CreateIndexDescriptor.cs
@@ -11,7 +11,7 @@
 namespace Nest
 {
 	[DescriptorFor("IndicesCreate")]
-	public partial class CreateIndexDescriptor : IPathInfo<CreateIndexQueryString>
+	public partial class CreateIndexDescriptor : IPathInfo<CreateIndexRequestParameters>
 	{
 		internal string _Index { get; set; }
 		internal IndexSettings _IndexSettings = new IndexSettings();
@@ -150,9 +150,9 @@ public CreateIndexDescriptor Analysis(Func<AnalysisDescriptor, AnalysisDescripto
 		}
 
 
-		ElasticsearchPathInfo<CreateIndexQueryString> IPathInfo<CreateIndexQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<CreateIndexRequestParameters> IPathInfo<CreateIndexRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = new ElasticsearchPathInfo<CreateIndexQueryString>();
+			var pathInfo = new ElasticsearchPathInfo<CreateIndexRequestParameters>();
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			pathInfo.Index = this._Index;
 			pathInfo.QueryString = this._QueryString;
diff --git a/src/Nest/DSL/DeleteByQueryDescriptor.cs b/src/Nest/DSL/DeleteByQueryDescriptor.cs
index bbea563ac52..083eb0ad2d1 100644
--- a/src/Nest/DSL/DeleteByQueryDescriptor.cs
+++ b/src/Nest/DSL/DeleteByQueryDescriptor.cs
@@ -12,8 +12,8 @@
 namespace Nest
 {
 	public partial class DeleteByQueryDescriptor<T> 
-		: QueryPathDescriptorBase<DeleteByQueryDescriptor<T>, T, DeleteByQueryQueryString>
-		, IPathInfo<DeleteByQueryQueryString> 
+		: QueryPathDescriptorBase<DeleteByQueryDescriptor<T>, T, DeleteByQueryRequestParameters>
+		, IPathInfo<DeleteByQueryRequestParameters> 
 		where T : class
 	{
 		[JsonProperty("query")]
@@ -31,9 +31,9 @@ public DeleteByQueryDescriptor<T> Query(Func<QueryDescriptor<T>, BaseQuery> quer
 			return this;
 		}
 
-		ElasticsearchPathInfo<DeleteByQueryQueryString> IPathInfo<DeleteByQueryQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<DeleteByQueryRequestParameters> IPathInfo<DeleteByQueryRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = this.ToPathInfo<DeleteByQueryQueryString>(settings, this._QueryString);
+			var pathInfo = this.ToPathInfo<DeleteByQueryRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.DELETE;
 			return pathInfo;
 		}
diff --git a/src/Nest/DSL/DeleteDescriptor.cs b/src/Nest/DSL/DeleteDescriptor.cs
index debcf670b6a..cf97e564a3f 100644
--- a/src/Nest/DSL/DeleteDescriptor.cs
+++ b/src/Nest/DSL/DeleteDescriptor.cs
@@ -13,13 +13,13 @@
 namespace Nest
 {
 	[DescriptorFor("Delete")]
-	public partial class DeleteDescriptor<T> : DocumentPathDescriptorBase<DeleteDescriptor<T>, T, DeleteQueryString>
-		, IPathInfo<DeleteQueryString>
+	public partial class DeleteDescriptor<T> : DocumentPathDescriptorBase<DeleteDescriptor<T>, T, DeleteRequestParameters>
+		, IPathInfo<DeleteRequestParameters>
 		where T : class
 	{
-		ElasticsearchPathInfo<DeleteQueryString> IPathInfo<DeleteQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<DeleteRequestParameters> IPathInfo<DeleteRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<DeleteQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<DeleteRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.DELETE;
 			return pathInfo;
 		}
diff --git a/src/Nest/DSL/DeleteIndexDescriptor.cs b/src/Nest/DSL/DeleteIndexDescriptor.cs
index 22173a7f5ce..3f3b48c3581 100644
--- a/src/Nest/DSL/DeleteIndexDescriptor.cs
+++ b/src/Nest/DSL/DeleteIndexDescriptor.cs
@@ -13,12 +13,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesDelete")]
 	public partial class DeleteIndexDescriptor : 
-		IndicesOptionalPathDescriptor<DeleteIndexDescriptor, DeleteIndexQueryString>
-		, IPathInfo<DeleteIndexQueryString>
+		IndicesOptionalPathDescriptor<DeleteIndexDescriptor, DeleteIndexRequestParameters>
+		, IPathInfo<DeleteIndexRequestParameters>
 	{
-		ElasticsearchPathInfo<DeleteIndexQueryString> IPathInfo<DeleteIndexQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<DeleteIndexRequestParameters> IPathInfo<DeleteIndexRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<DeleteIndexQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<DeleteIndexRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.DELETE;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/DeleteMappingDescriptor.cs b/src/Nest/DSL/DeleteMappingDescriptor.cs
index 090dd334512..c2354c8b461 100644
--- a/src/Nest/DSL/DeleteMappingDescriptor.cs
+++ b/src/Nest/DSL/DeleteMappingDescriptor.cs
@@ -13,12 +13,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesDeleteMapping")]
 	public partial class DeleteMappingDescriptor : 
-		IndexTypePathDescriptor<DeleteMappingDescriptor, DeleteMappingQueryString>
-		, IPathInfo<DeleteMappingQueryString>
+		IndexTypePathDescriptor<DeleteMappingDescriptor, DeleteMappingRequestParameters>
+		, IPathInfo<DeleteMappingRequestParameters>
 	{
-		ElasticsearchPathInfo<DeleteMappingQueryString> IPathInfo<DeleteMappingQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<DeleteMappingRequestParameters> IPathInfo<DeleteMappingRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<DeleteMappingQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<DeleteMappingRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.DELETE;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/DeleteTemplateDescriptor.cs b/src/Nest/DSL/DeleteTemplateDescriptor.cs
index 28cdf765ef0..759992c7c65 100644
--- a/src/Nest/DSL/DeleteTemplateDescriptor.cs
+++ b/src/Nest/DSL/DeleteTemplateDescriptor.cs
@@ -14,12 +14,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesDeleteTemplate")]
 	public partial class DeleteTemplateDescriptor :
-		NamePathDescriptor<DeleteTemplateDescriptor, DeleteTemplateQueryString>
-		, IPathInfo<DeleteTemplateQueryString>
+		NamePathDescriptor<DeleteTemplateDescriptor, DeleteTemplateRequestParameters>
+		, IPathInfo<DeleteTemplateRequestParameters>
 	{
-		ElasticsearchPathInfo<DeleteTemplateQueryString> IPathInfo<DeleteTemplateQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<DeleteTemplateRequestParameters> IPathInfo<DeleteTemplateRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<DeleteTemplateQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<DeleteTemplateRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.DELETE;
 			
 			return pathInfo;
diff --git a/src/Nest/DSL/DeleteWarmerDescriptor.cs b/src/Nest/DSL/DeleteWarmerDescriptor.cs
index f1eab49080d..b76eca1018a 100644
--- a/src/Nest/DSL/DeleteWarmerDescriptor.cs
+++ b/src/Nest/DSL/DeleteWarmerDescriptor.cs
@@ -13,12 +13,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesDeleteWarmer")]
 	public partial class DeleteWarmerDescriptor : 
-		IndicesOptionalTypesNamePathDecriptor<DeleteWarmerDescriptor, DeleteWarmerQueryString>
-		, IPathInfo<DeleteWarmerQueryString>
+		IndicesOptionalTypesNamePathDecriptor<DeleteWarmerDescriptor, DeleteWarmerRequestParameters>
+		, IPathInfo<DeleteWarmerRequestParameters>
 	{
-		ElasticsearchPathInfo<DeleteWarmerQueryString> IPathInfo<DeleteWarmerQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<DeleteWarmerRequestParameters> IPathInfo<DeleteWarmerRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<DeleteWarmerQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<DeleteWarmerRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.DELETE;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/FlushDescriptor.cs b/src/Nest/DSL/FlushDescriptor.cs
index 140a73286fc..ab5011cc7fe 100644
--- a/src/Nest/DSL/FlushDescriptor.cs
+++ b/src/Nest/DSL/FlushDescriptor.cs
@@ -13,12 +13,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesFlush")]
 	public partial class FlushDescriptor : 
-		IndicesOptionalExplicitAllPathDescriptor<FlushDescriptor, FlushQueryString>
-		, IPathInfo<FlushQueryString>
+		IndicesOptionalExplicitAllPathDescriptor<FlushDescriptor, FlushRequestParameters>
+		, IPathInfo<FlushRequestParameters>
 	{
-		ElasticsearchPathInfo<FlushQueryString> IPathInfo<FlushQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<FlushRequestParameters> IPathInfo<FlushRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<FlushQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<FlushRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/GetAliasesDescriptor.cs b/src/Nest/DSL/GetAliasesDescriptor.cs
index 064a4dd6fed..076c54dcfeb 100644
--- a/src/Nest/DSL/GetAliasesDescriptor.cs
+++ b/src/Nest/DSL/GetAliasesDescriptor.cs
@@ -13,8 +13,8 @@ namespace Nest
 {
 	[DescriptorFor("IndicesGetAlias")]
 	public partial class GetAliasesDescriptor : 
-		IndicesOptionalPathDescriptor<GetAliasesDescriptor, GetAliasesQueryString>
-		, IPathInfo<GetAliasesQueryString>
+		IndicesOptionalPathDescriptor<GetAliasesDescriptor, GetAliasesRequestParameters>
+		, IPathInfo<GetAliasesRequestParameters>
 	{
 		internal string _Alias { get; set; }
 
@@ -24,9 +24,9 @@ public GetAliasesDescriptor Alias(string alias)
 			return this;
 		}
 
-		ElasticsearchPathInfo<GetAliasesQueryString> IPathInfo<GetAliasesQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<GetAliasesRequestParameters> IPathInfo<GetAliasesRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<GetAliasesQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<GetAliasesRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 			pathInfo.Name = _Alias ?? "*";
 			return pathInfo;
diff --git a/src/Nest/DSL/GetDescriptor.cs b/src/Nest/DSL/GetDescriptor.cs
index a4be3ebab8c..2fc5adad6be 100644
--- a/src/Nest/DSL/GetDescriptor.cs
+++ b/src/Nest/DSL/GetDescriptor.cs
@@ -10,8 +10,8 @@
 
 namespace Nest
 {
-	public partial class GetDescriptor<T> : DocumentPathDescriptorBase<GetDescriptor<T>,T, GetQueryString>
-		, IPathInfo<GetQueryString>
+	public partial class GetDescriptor<T> : DocumentPathDescriptorBase<GetDescriptor<T>,T, GetRequestParameters>
+		, IPathInfo<GetRequestParameters>
 		where T : class
 	{
 
@@ -25,9 +25,9 @@ public GetDescriptor<T> ExecuteOnLocalShard()
 			return this.Preference("_local");
 		}
 
-		ElasticsearchPathInfo<GetQueryString> IPathInfo<GetQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<GetRequestParameters> IPathInfo<GetRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = this.ToPathInfo<GetQueryString>(settings, this._QueryString);
+			var pathInfo = this.ToPathInfo<GetRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/GetIndexSettingsDescriptor.cs b/src/Nest/DSL/GetIndexSettingsDescriptor.cs
index ad486fb3895..9ebea5a0ddf 100644
--- a/src/Nest/DSL/GetIndexSettingsDescriptor.cs
+++ b/src/Nest/DSL/GetIndexSettingsDescriptor.cs
@@ -13,12 +13,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesGetSettings")]
 	public partial class GetIndexSettingsDescriptor : 
-		IndexPathDescriptorBase<GetIndexSettingsDescriptor, GetIndexSettingsQueryString>
-		, IPathInfo<GetIndexSettingsQueryString>
+		IndexPathDescriptorBase<GetIndexSettingsDescriptor, GetIndexSettingsRequestParameters>
+		, IPathInfo<GetIndexSettingsRequestParameters>
 	{
-		ElasticsearchPathInfo<GetIndexSettingsQueryString> IPathInfo<GetIndexSettingsQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<GetIndexSettingsRequestParameters> IPathInfo<GetIndexSettingsRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<GetIndexSettingsQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<GetIndexSettingsRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/GetMappingDescriptor.cs b/src/Nest/DSL/GetMappingDescriptor.cs
index 7ec68eef906..5e9bc6b09c7 100644
--- a/src/Nest/DSL/GetMappingDescriptor.cs
+++ b/src/Nest/DSL/GetMappingDescriptor.cs
@@ -13,12 +13,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesGetMapping")]
 	public partial class GetMappingDescriptor : 
-		IndexTypePathDescriptor<GetMappingDescriptor, GetMappingQueryString>
-		, IPathInfo<GetMappingQueryString>
+		IndexTypePathDescriptor<GetMappingDescriptor, GetMappingRequestParameters>
+		, IPathInfo<GetMappingRequestParameters>
 	{
-		ElasticsearchPathInfo<GetMappingQueryString> IPathInfo<GetMappingQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<GetMappingRequestParameters> IPathInfo<GetMappingRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<GetMappingQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<GetMappingRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/GetTemplateDescriptor.cs b/src/Nest/DSL/GetTemplateDescriptor.cs
index 16baaf66896..44708ef4ee2 100644
--- a/src/Nest/DSL/GetTemplateDescriptor.cs
+++ b/src/Nest/DSL/GetTemplateDescriptor.cs
@@ -14,12 +14,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesGetTemplate")]
 	public partial class GetTemplateDescriptor :
-		NamePathDescriptor<GetTemplateDescriptor, GetTemplateQueryString>
-		, IPathInfo<GetTemplateQueryString>
+		NamePathDescriptor<GetTemplateDescriptor, GetTemplateRequestParameters>
+		, IPathInfo<GetTemplateRequestParameters>
 	{
-		ElasticsearchPathInfo<GetTemplateQueryString> IPathInfo<GetTemplateQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<GetTemplateRequestParameters> IPathInfo<GetTemplateRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<GetTemplateQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<GetTemplateRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/GetWarmerDescriptor.cs b/src/Nest/DSL/GetWarmerDescriptor.cs
index 75535ef8190..a2797188932 100644
--- a/src/Nest/DSL/GetWarmerDescriptor.cs
+++ b/src/Nest/DSL/GetWarmerDescriptor.cs
@@ -13,12 +13,12 @@ namespace Nest
 {
 	[DescriptorFor("IndicesGetWarmer")]
 	public partial class GetWarmerDescriptor : 
-		IndicesOptionalTypesNamePathDecriptor<GetWarmerDescriptor, GetWarmerQueryString>
-		, IPathInfo<GetWarmerQueryString>
+		IndicesOptionalTypesNamePathDecriptor<GetWarmerDescriptor, GetWarmerRequestParameters>
+		, IPathInfo<GetWarmerRequestParameters>
 	{
-		ElasticsearchPathInfo<GetWarmerQueryString> IPathInfo<GetWarmerQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<GetWarmerRequestParameters> IPathInfo<GetWarmerRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<GetWarmerQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<GetWarmerRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/IndexDescriptor.cs b/src/Nest/DSL/IndexDescriptor.cs
index dca9ce390cd..6f68f71aa33 100644
--- a/src/Nest/DSL/IndexDescriptor.cs
+++ b/src/Nest/DSL/IndexDescriptor.cs
@@ -13,13 +13,13 @@
 namespace Nest
 {
 	[DescriptorFor("Index")]
-	public partial class IndexDescriptor<T> : DocumentPathDescriptorBase<IndexDescriptor<T>, T, IndexQueryString>
-		, IPathInfo<IndexQueryString>
+	public partial class IndexDescriptor<T> : DocumentPathDescriptorBase<IndexDescriptor<T>, T, IndexRequestParameters>
+		, IPathInfo<IndexRequestParameters>
 		where T : class
 	{
-		ElasticsearchPathInfo<IndexQueryString> IPathInfo<IndexQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<IndexRequestParameters> IPathInfo<IndexRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<IndexQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<IndexRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = this._Id.IsNullOrEmpty() ? PathInfoHttpMethod.POST : PathInfoHttpMethod.PUT;
 			return pathInfo;
 		}
diff --git a/src/Nest/DSL/IndexExistsDescriptor.cs b/src/Nest/DSL/IndexExistsDescriptor.cs
index 8f149932685..1651f4a8b9f 100644
--- a/src/Nest/DSL/IndexExistsDescriptor.cs
+++ b/src/Nest/DSL/IndexExistsDescriptor.cs
@@ -13,12 +13,12 @@
 namespace Nest
 {
 	[DescriptorFor("IndicesExists")]
-	public partial class IndexExistsDescriptor : IndexPathDescriptorBase<IndexExistsDescriptor, IndexExistsQueryString>
-		, IPathInfo<IndexExistsQueryString>
+	public partial class IndexExistsDescriptor : IndexPathDescriptorBase<IndexExistsDescriptor, IndexExistsRequestParameters>
+		, IPathInfo<IndexExistsRequestParameters>
 	{
-		ElasticsearchPathInfo<IndexExistsQueryString> IPathInfo<IndexExistsQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<IndexExistsRequestParameters> IPathInfo<IndexExistsRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<IndexExistsQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<IndexExistsRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.HEAD;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/IndicesStatsDescriptor.cs b/src/Nest/DSL/IndicesStatsDescriptor.cs
index a35edaa8415..eaa36f4b68c 100644
--- a/src/Nest/DSL/IndicesStatsDescriptor.cs
+++ b/src/Nest/DSL/IndicesStatsDescriptor.cs
@@ -13,8 +13,8 @@ namespace Nest
 {
 	[DescriptorFor("IndicesStats")]
 	public partial class IndicesStatsDescriptor : 
-		IndicesOptionalPathDescriptor<IndicesStatsDescriptor, IndicesStatsQueryString>
-		, IPathInfo<IndicesStatsQueryString>
+		IndicesOptionalPathDescriptor<IndicesStatsDescriptor, IndicesStatsRequestParameters>
+		, IPathInfo<IndicesStatsRequestParameters>
 	{
 		private IEnumerable<TypeNameMarker> _Types { get; set; }
 		private IEnumerable<IndicesStatsMetric> _Metrics { get; set; }
@@ -32,9 +32,9 @@ public IndicesStatsDescriptor Metrics(params IndicesStatsMetric[] metrics)
 			return this;
 		}
 
-		ElasticsearchPathInfo<IndicesStatsQueryString> IPathInfo<IndicesStatsQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<IndicesStatsRequestParameters> IPathInfo<IndicesStatsRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<IndicesStatsQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<IndicesStatsRequestParameters>(settings, this._QueryString);
 			if (this._Types.HasAny())
 			{
 				var inferrer = new ElasticInferrer(settings);
diff --git a/src/Nest/DSL/IndicesStatusDescriptor.cs b/src/Nest/DSL/IndicesStatusDescriptor.cs
index 72c64fa86b7..459c15c20bd 100644
--- a/src/Nest/DSL/IndicesStatusDescriptor.cs
+++ b/src/Nest/DSL/IndicesStatusDescriptor.cs
@@ -13,13 +13,13 @@ namespace Nest
 {
 	[DescriptorFor("IndicesStatus")]
 	public partial class IndicesStatusDescriptor : 
-		IndicesOptionalPathDescriptor<IndicesStatusDescriptor, IndicesStatsQueryString>
-		, IPathInfo<IndicesStatusQueryString>
+		IndicesOptionalPathDescriptor<IndicesStatusDescriptor, IndicesStatsRequestParameters>
+		, IPathInfo<IndicesStatusRequestParameters>
 	{
 		
-		ElasticsearchPathInfo<IndicesStatusQueryString> IPathInfo<IndicesStatusQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<IndicesStatusRequestParameters> IPathInfo<IndicesStatusRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<IndicesStatusQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<IndicesStatusRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/InfoDescriptor.cs b/src/Nest/DSL/InfoDescriptor.cs
index 405cdf12223..fd24f7b5278 100644
--- a/src/Nest/DSL/InfoDescriptor.cs
+++ b/src/Nest/DSL/InfoDescriptor.cs
@@ -13,11 +13,11 @@ namespace Nest
 {
 	[DescriptorFor("Info")]
 	public partial class InfoDescriptor : 
-		 IPathInfo<InfoQueryString>
+		 IPathInfo<InfoRequestParameters>
 	{
-		ElasticsearchPathInfo<InfoQueryString> IPathInfo<InfoQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<InfoRequestParameters> IPathInfo<InfoRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = new ElasticsearchPathInfo<InfoQueryString>();
+			var pathInfo = new ElasticsearchPathInfo<InfoRequestParameters>();
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 			pathInfo.QueryString = this._QueryString;
 
diff --git a/src/Nest/DSL/MoreLikeThisDescriptor.cs b/src/Nest/DSL/MoreLikeThisDescriptor.cs
index fca80ef07b1..cacc08d1e75 100644
--- a/src/Nest/DSL/MoreLikeThisDescriptor.cs
+++ b/src/Nest/DSL/MoreLikeThisDescriptor.cs
@@ -13,8 +13,8 @@ namespace Nest
 {
 	[DescriptorFor("Mlt")]
 	public partial class MoreLikeThisDescriptor<T> 
-		: DocumentPathDescriptorBase<MoreLikeThisDescriptor<T>, T, MoreLikeThisQueryString>
-		, IPathInfo<MoreLikeThisQueryString> 
+		: DocumentPathDescriptorBase<MoreLikeThisDescriptor<T>, T, MoreLikeThisRequestParameters>
+		, IPathInfo<MoreLikeThisRequestParameters> 
 		where T : class
 	{
 		internal SearchDescriptor<T> _Search { get; set; }
@@ -30,9 +30,9 @@ public MoreLikeThisDescriptor<T> Search(Func<SearchDescriptor<T>, SearchDescript
 			return this;
 		}
 
-		ElasticsearchPathInfo<MoreLikeThisQueryString> IPathInfo<MoreLikeThisQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<MoreLikeThisRequestParameters> IPathInfo<MoreLikeThisRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<MoreLikeThisQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<MoreLikeThisRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = this._Search == null ? PathInfoHttpMethod.GET : PathInfoHttpMethod.POST;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/MultiGetDescriptor.cs b/src/Nest/DSL/MultiGetDescriptor.cs
index 576c2146b2b..03b75f50477 100644
--- a/src/Nest/DSL/MultiGetDescriptor.cs
+++ b/src/Nest/DSL/MultiGetDescriptor.cs
@@ -13,8 +13,8 @@ namespace Nest
 {
 
 	[DescriptorFor("Mget")]
-	public partial class MultiGetDescriptor : FixedIndexTypePathDescriptor<MultiGetDescriptor, MultiGetQueryString>
-		, IPathInfo<MultiGetQueryString>
+	public partial class MultiGetDescriptor : FixedIndexTypePathDescriptor<MultiGetDescriptor, MultiGetRequestParameters>
+		, IPathInfo<MultiGetRequestParameters>
 	{
 		internal readonly IList<ISimpleGetDescriptor> _GetOperations = new List<ISimpleGetDescriptor>();
 		private readonly IConnectionSettingsValues _settings;
@@ -69,9 +69,9 @@ public MultiGetDescriptor GetMany<K>(IEnumerable<string> ids, Func<SimpleGetDesc
 			return this;
 
 		}
-		ElasticsearchPathInfo<MultiGetQueryString> IPathInfo<MultiGetQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<MultiGetRequestParameters> IPathInfo<MultiGetRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = this.ToPathInfo<MultiGetQueryString>(settings, this._QueryString);
+			var pathInfo = this.ToPathInfo<MultiGetRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST; // no data in GETS in the .net world
 			return pathInfo;
 		}
diff --git a/src/Nest/DSL/MultiSearchDescriptor.cs b/src/Nest/DSL/MultiSearchDescriptor.cs
index 220e792d442..efc30fd525d 100644
--- a/src/Nest/DSL/MultiSearchDescriptor.cs
+++ b/src/Nest/DSL/MultiSearchDescriptor.cs
@@ -13,8 +13,8 @@ namespace Nest
 {
 	[DescriptorFor("Msearch")]
 	public partial class MultiSearchDescriptor 
-		: FixedIndexTypePathDescriptor<MultiSearchDescriptor, MultiSearchQueryString>
-		, IPathInfo<MultiSearchQueryString>
+		: FixedIndexTypePathDescriptor<MultiSearchDescriptor, MultiSearchRequestParameters>
+		, IPathInfo<MultiSearchRequestParameters>
 	{
 
 		[JsonConverter(typeof(DictionaryKeysAreNotPropertyNamesJsonConverter))]
@@ -36,9 +36,9 @@ public MultiSearchDescriptor Search<T>(Func<SearchDescriptor<T>, SearchDescripto
 			return this.Search(Guid.NewGuid().ToString(), searchSelector);
 		}
 
-		ElasticsearchPathInfo<MultiSearchQueryString> IPathInfo<MultiSearchQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<MultiSearchRequestParameters> IPathInfo<MultiSearchRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<MultiSearchQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<MultiSearchRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			return pathInfo;
 		}
diff --git a/src/Nest/DSL/NodesInfoDescriptor.cs b/src/Nest/DSL/NodesInfoDescriptor.cs
index 07b0fc5262c..fdc4cb8f58e 100644
--- a/src/Nest/DSL/NodesInfoDescriptor.cs
+++ b/src/Nest/DSL/NodesInfoDescriptor.cs
@@ -11,8 +11,8 @@
 namespace Nest
 {
 	[DescriptorFor("NodesInfo")]
-	public partial class NodesInfoDescriptor : NodeIdOptionalDescriptor<NodesInfoDescriptor, NodesInfoQueryString>
-		, IPathInfo<NodesInfoQueryString>
+	public partial class NodesInfoDescriptor : NodeIdOptionalDescriptor<NodesInfoDescriptor, NodesInfoRequestParameters>
+		, IPathInfo<NodesInfoRequestParameters>
 	{
 		private IEnumerable<NodesInfoMetric> _Metrics { get; set; }
 		public NodesInfoDescriptor Metrics(params NodesInfoMetric[] metrics)
@@ -20,9 +20,9 @@ public NodesInfoDescriptor Metrics(params NodesInfoMetric[] metrics)
 			this._Metrics = metrics;
 			return this;
 		}
-		ElasticsearchPathInfo<NodesInfoQueryString> IPathInfo<NodesInfoQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<NodesInfoRequestParameters> IPathInfo<NodesInfoRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<NodesInfoQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<NodesInfoRequestParameters>(settings, this._QueryString);
 			if (this._Metrics != null)
 				pathInfo.Metric = this._Metrics.Cast<Enum>().GetStringValue();
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
diff --git a/src/Nest/DSL/NodesStatsDescriptor.cs b/src/Nest/DSL/NodesStatsDescriptor.cs
index 67f437a8247..b7c4e794e04 100644
--- a/src/Nest/DSL/NodesStatsDescriptor.cs
+++ b/src/Nest/DSL/NodesStatsDescriptor.cs
@@ -11,8 +11,8 @@
 namespace Nest
 {
 	[DescriptorFor("NodesStats")]
-	public partial class NodesStatsDescriptor : NodeIdOptionalDescriptor<NodesStatsDescriptor, NodesStatsQueryString>
-		, IPathInfo<NodesStatsQueryString>
+	public partial class NodesStatsDescriptor : NodeIdOptionalDescriptor<NodesStatsDescriptor, NodesStatsRequestParameters>
+		, IPathInfo<NodesStatsRequestParameters>
 	{
 		private IEnumerable<NodesStatsMetric> _Metrics { get; set; }
 		private IEnumerable<NodesStatsIndexMetric> _IndexMetrics { get; set; }
@@ -28,9 +28,9 @@ public NodesStatsDescriptor IndexMetrics(params NodesStatsIndexMetric[] metrics)
 			return this;
 		}
 
-		ElasticsearchPathInfo<NodesStatsQueryString> IPathInfo<NodesStatsQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<NodesStatsRequestParameters> IPathInfo<NodesStatsRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<NodesStatsQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<NodesStatsRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 			if (this._Metrics != null)
 				pathInfo.Metric = this._Metrics.Cast<Enum>().GetStringValue();
diff --git a/src/Nest/DSL/OpenIndexDescriptor.cs b/src/Nest/DSL/OpenIndexDescriptor.cs
index dc7d9fc1f2b..dc8ffa12973 100644
--- a/src/Nest/DSL/OpenIndexDescriptor.cs
+++ b/src/Nest/DSL/OpenIndexDescriptor.cs
@@ -13,12 +13,12 @@
 namespace Nest
 {
 	[DescriptorFor("IndicesOpen")]
-	public partial class OpenIndexDescriptor : IndexPathDescriptorBase<OpenIndexDescriptor, OpenIndexQueryString>
-		, IPathInfo<OpenIndexQueryString>
+	public partial class OpenIndexDescriptor : IndexPathDescriptorBase<OpenIndexDescriptor, OpenIndexRequestParameters>
+		, IPathInfo<OpenIndexRequestParameters>
 	{
-		ElasticsearchPathInfo<OpenIndexQueryString> IPathInfo<OpenIndexQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<OpenIndexRequestParameters> IPathInfo<OpenIndexRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<OpenIndexQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<OpenIndexRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			
 			return pathInfo;
diff --git a/src/Nest/DSL/OptimizeDescriptor.cs b/src/Nest/DSL/OptimizeDescriptor.cs
index 78952d09df4..72e7713674a 100644
--- a/src/Nest/DSL/OptimizeDescriptor.cs
+++ b/src/Nest/DSL/OptimizeDescriptor.cs
@@ -13,12 +13,12 @@
 namespace Nest
 {
 	[DescriptorFor("IndicesOptimize")]
-	public partial class OptimizeDescriptor : IndicesOptionalPathDescriptor<OptimizeDescriptor, OptimizeQueryString>
-		, IPathInfo<OptimizeQueryString>
+	public partial class OptimizeDescriptor : IndicesOptionalPathDescriptor<OptimizeDescriptor, OptimizeRequestParameters>
+		, IPathInfo<OptimizeRequestParameters>
 	{
-		ElasticsearchPathInfo<OptimizeQueryString> IPathInfo<OptimizeQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<OptimizeRequestParameters> IPathInfo<OptimizeRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<OptimizeQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<OptimizeRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			
 			return pathInfo;
diff --git a/src/Nest/DSL/Paths/DocumentPathDescriptor.cs b/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
index c6c7f8e6305..812cf90fbcd 100644
--- a/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
@@ -21,7 +21,7 @@ namespace Nest
 	public class DocumentPathDescriptorBase<P, T, K>
 		where P : DocumentPathDescriptorBase<P, T, K>, new()
 		where T : class
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 
 		internal IndexNameMarker _Index { get; set; }
@@ -77,7 +77,7 @@ public P Object(T @object)
 			return (P)this;
 		}
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var inferrer = new ElasticInferrer(settings);
 			var index = this._Index != null ? inferrer.IndexName(this._Index) : inferrer.IndexName<T>();
diff --git a/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs b/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
index de31d5a7d05..a07c2ee64a0 100644
--- a/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
@@ -21,7 +21,7 @@ namespace Nest
 	/// </summary>
 	public class FixedIndexTypePathDescriptor<P, K> 
 		where P : FixedIndexTypePathDescriptor<P, K> 
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal IndexNameMarker _Index { get; set; }
 		internal TypeNameMarker _Type { get; set; }
@@ -54,7 +54,7 @@ public P FixedPath<TIndex,TType>()
 		}
 		
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var inferrer = new ElasticInferrer(settings);
 
diff --git a/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs b/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
index 8f650c1a0f4..106eb5e7b9d 100644
--- a/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
@@ -20,7 +20,7 @@ namespace Nest
 	/// </summary>
 	public class IndexNamePathDescriptor<P, K> 
 		where P : IndexNamePathDescriptor<P, K>, new()
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal IndexNameMarker _Index { get; set; }
 		internal string _Name { get; set; }
@@ -50,7 +50,7 @@ public P Name(string name)
 		}
 
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			if (this._Name == null)
 				throw new DslException("missing Name()");
diff --git a/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs b/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
index 22be0696dce..8be6a20ed6a 100644
--- a/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
@@ -20,7 +20,7 @@ namespace Nest
 	/// </summary>
 	public class IndexOptionalPathDescriptorBase<P, K> 
 		where P : IndexOptionalPathDescriptorBase<P, K>, new()
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal IndexNameMarker _Index { get; set; }
 		
@@ -51,7 +51,7 @@ public P Index(Type indexType)
 		}
 
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var inferrer = new ElasticInferrer(settings);
 			if (!this._AllIndices.HasValue && this._Index == null)
diff --git a/src/Nest/DSL/Paths/IndexPathDescriptor.cs b/src/Nest/DSL/Paths/IndexPathDescriptor.cs
index fb01cb83c9d..7f26ae17c91 100644
--- a/src/Nest/DSL/Paths/IndexPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexPathDescriptor.cs
@@ -20,7 +20,7 @@ namespace Nest
 	/// </summary>
 	public class IndexPathDescriptorBase<P, K> 
 		where P : IndexPathDescriptorBase<P, K>, new()
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal IndexNameMarker _Index { get; set; }
 		
@@ -43,7 +43,7 @@ public P Index(Type indexType)
 		}
 
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			if (this._Index == null)
 				throw new DslException("missing call to Index()");
diff --git a/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs b/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
index 97a0c3d3b45..e8b71f79414 100644
--- a/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
@@ -21,7 +21,7 @@ namespace Nest
 	/// </summary>
 	public class IndexTypePathDescriptor<P, K> 
 		where P : IndexTypePathDescriptor<P, K>, new()
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal IndexNameMarker _Index { get; set; }
 		internal TypeNameMarker _Type { get; set; }
@@ -63,7 +63,7 @@ public P Type(Type type)
 		}
 		
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var inferrer = new ElasticInferrer(settings);
 			if (this._Index == null)
diff --git a/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs b/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
index 889e211d5ed..0dec18d8196 100644
--- a/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
@@ -20,7 +20,7 @@ namespace Nest
 	/// </summary>
 	public class IndexTypePathTypedDescriptor<P, K, T> 
 		where P : IndexTypePathTypedDescriptor<P, K, T>, new()
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 		where T : class
 	{
 		internal IndexNameMarker _Index { get; set; }
@@ -63,7 +63,7 @@ public P Type(Type type)
 		}
 		
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var inferrer = new ElasticInferrer(settings);
 			if (this._Index == null)
diff --git a/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
index 8a7c85acfb7..e128d2d2d3e 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
@@ -21,7 +21,7 @@ namespace Nest
 	/// </summary>
 	public class IndicesOptionalExplicitAllPathDescriptor<P, K> 
 		where P : IndicesOptionalExplicitAllPathDescriptor<P, K>, new()
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal IEnumerable<IndexNameMarker> _Indices { get; set; }
 		
@@ -56,7 +56,7 @@ public P Indices(params Type[] indicesTypes)
 		}
 
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var inferrer = new ElasticInferrer(settings);
 			if (!this._AllIndices.HasValue && this._Indices == null)
diff --git a/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
index 753e09c4728..eceb5520cea 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
@@ -20,7 +20,7 @@ namespace Nest
 	/// </summary>
 	public class IndicesOptionalPathDescriptor<P, K> 
 		where P : IndicesOptionalPathDescriptor<P, K>, new()
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal IEnumerable<IndexNameMarker> _Indices { get; set; }
 		
@@ -47,7 +47,7 @@ public P Indices(params Type[] indicesTypes)
 		}
 
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var index = this._Indices == null ? null : string.Join(",", this._Indices.Select(i => new ElasticInferrer(settings).IndexName(i)));
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
index a865e45f0c8..8b68bfcfff0 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
@@ -22,7 +22,7 @@ namespace Nest
 	/// </summary>
 	public class IndicesOptionalTypesNamePathDecriptor<P, K>
 		where P : IndicesOptionalTypesNamePathDecriptor<P, K>, new()
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal bool? _AllIndices { get; set; }
 
@@ -115,7 +115,7 @@ public P Name(string name)
 		}
 
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var inferrer = new ElasticInferrer(settings);
 			if (!this._AllIndices.HasValue && this._Indices == null)
diff --git a/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs b/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
index d889d6abc59..87fb3ef31bf 100644
--- a/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
@@ -20,7 +20,7 @@ namespace Nest
 	/// </summary>
 	public class IndicesTypePathDescriptor<P, K, T> 
 		where P : IndicesTypePathDescriptor<P, K, T> 
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 		where T : class
 	{
 		internal bool? _AllIndices { get; set; }
@@ -71,7 +71,7 @@ public P Type(Type type)
 		}
 		
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var inferrer = new ElasticInferrer(settings);
 			if (this._Type == null)
diff --git a/src/Nest/DSL/Paths/NamePathDescriptor.cs b/src/Nest/DSL/Paths/NamePathDescriptor.cs
index 1a2dae25dd8..8fb92f875ee 100644
--- a/src/Nest/DSL/Paths/NamePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/NamePathDescriptor.cs
@@ -20,7 +20,7 @@ namespace Nest
 	/// </summary>
 	public class NamePathDescriptor<P, K>
 		where P : NamePathDescriptor<P, K> 
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal string _Name { get; set; }
 
@@ -34,7 +34,7 @@ public P Name(string name)
 		}
 
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			if (this._Name.IsNullOrEmpty())
 				throw new DslException("missing Name()");
diff --git a/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs b/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
index 959fc311932..b9846dcde30 100644
--- a/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
+++ b/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
@@ -20,7 +20,7 @@ namespace Nest
 	/// </summary>
 	public class NodeIdOptionalDescriptor<P, K>
 		where P : NodeIdOptionalDescriptor<P, K> 
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal string _NodeId { get; set; }
 
@@ -34,7 +34,7 @@ public P NodeId(string nodeId)
 		}
 
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			var pathInfo = new ElasticsearchPathInfo<K>()
 			{
diff --git a/src/Nest/DSL/Paths/QueryPathDescriptor.cs b/src/Nest/DSL/Paths/QueryPathDescriptor.cs
index b5c0bef2cad..d2ccc9dbcd0 100644
--- a/src/Nest/DSL/Paths/QueryPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/QueryPathDescriptor.cs
@@ -11,13 +11,6 @@
 
 namespace Nest
 {
-
-	public class QueryPathDescriptor<T> : QueryPathDescriptorBase<QueryPathDescriptor<T>, T, BulkQueryString>
-		where T : class
-	{
-
-	}
-
 	/// <summary>
 	/// Provides a base for descriptors that need to describe a path in the form of 
 	/// <pre>
@@ -28,7 +21,7 @@ public class QueryPathDescriptor<T> : QueryPathDescriptorBase<QueryPathDescripto
 	public class QueryPathDescriptorBase<P, T, K>
 		where P : QueryPathDescriptorBase<P, T, K>, new()
 		where T : class
-		where K : FluentQueryString<K>, new()
+		where K : FluentRequestParameters<K>, new()
 	{
 		internal IEnumerable<IndexNameMarker> _Indices { get; set; }
 		internal IEnumerable<TypeNameMarker> _Types { get; set; }
@@ -118,7 +111,7 @@ public P AllTypes()
 		}
 
 		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentQueryString<K>, new()
+			where K : FluentRequestParameters<K>, new()
 		{
 			//start out with defaults
 			var inferrer = new ElasticInferrer(settings);
diff --git a/src/Nest/DSL/PercolateDescriptor.cs b/src/Nest/DSL/PercolateDescriptor.cs
index d999c0ad5b0..80d430f9b65 100644
--- a/src/Nest/DSL/PercolateDescriptor.cs
+++ b/src/Nest/DSL/PercolateDescriptor.cs
@@ -11,8 +11,8 @@
 
 namespace Nest
 {
-	public partial class PercolateDescriptor<T,K> : IndexTypePathTypedDescriptor<PercolateDescriptor<T, K>, PercolateQueryString, T> 
-		, IPathInfo<PercolateQueryString> 
+	public partial class PercolateDescriptor<T,K> : IndexTypePathTypedDescriptor<PercolateDescriptor<T, K>, PercolateRequestParameters, T> 
+		, IPathInfo<PercolateRequestParameters> 
 		where T : class
 		where K : class
 	{
@@ -42,9 +42,9 @@ public PercolateDescriptor<T, K> Query(Func<QueryDescriptor<T>, BaseQuery> query
 			return this;
 		}
 
-		ElasticsearchPathInfo<PercolateQueryString> IPathInfo<PercolateQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<PercolateRequestParameters> IPathInfo<PercolateRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<PercolateQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<PercolateRequestParameters>(settings, this._QueryString);
 			//.NET does not like sending data using get so we use POST
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			return pathInfo;
diff --git a/src/Nest/DSL/PutMappingDescriptor.cs b/src/Nest/DSL/PutMappingDescriptor.cs
index 6d78ba1f926..2589ba2b682 100644
--- a/src/Nest/DSL/PutMappingDescriptor.cs
+++ b/src/Nest/DSL/PutMappingDescriptor.cs
@@ -9,8 +9,8 @@ namespace Nest
 {
 	[DescriptorFor("IndicesPutMapping")]
 	public partial class PutMappingDescriptor<T> 
-		: IndicesTypePathDescriptor<PutMappingDescriptor<T>, PutMappingQueryString, T>
-		, IPathInfo<PutMappingQueryString> 
+		: IndicesTypePathDescriptor<PutMappingDescriptor<T>, PutMappingRequestParameters, T>
+		, IPathInfo<PutMappingRequestParameters> 
 		where T : class
 	{
 		private readonly IConnectionSettingsValues _connectionSettings;
@@ -231,9 +231,9 @@ public PutMappingDescriptor<T> DynamicTemplates(Func<DynamicTemplatesDescriptor<
 			return this;
 		}
 
-		ElasticsearchPathInfo<PutMappingQueryString> IPathInfo<PutMappingQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<PutMappingRequestParameters> IPathInfo<PutMappingRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<PutMappingQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<PutMappingRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.PUT;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/PutTemplateDescriptor.cs b/src/Nest/DSL/PutTemplateDescriptor.cs
index bf863d2bd8e..377391da6a2 100644
--- a/src/Nest/DSL/PutTemplateDescriptor.cs
+++ b/src/Nest/DSL/PutTemplateDescriptor.cs
@@ -7,8 +7,8 @@
 namespace Nest
 {
 	[DescriptorFor("IndicesPutTemplate")]
-	public partial class PutTemplateDescriptor : NamePathDescriptor<PutTemplateDescriptor, PutTemplateQueryString>
-		, IPathInfo<PutTemplateQueryString>
+	public partial class PutTemplateDescriptor : NamePathDescriptor<PutTemplateDescriptor, PutTemplateRequestParameters>
+		, IPathInfo<PutTemplateRequestParameters>
 	{
 		private readonly IConnectionSettingsValues _connectionSettings;
 
@@ -86,9 +86,9 @@ public PutTemplateDescriptor AddWarmer<T>(Func<CreateWarmerDescriptor, CreateWar
 
 		}
 
-		ElasticsearchPathInfo<PutTemplateQueryString> IPathInfo<PutTemplateQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<PutTemplateRequestParameters> IPathInfo<PutTemplateRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<PutTemplateQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<PutTemplateRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.PUT;
 			pathInfo.Name = this._Name;
 			return pathInfo;
diff --git a/src/Nest/DSL/PutWarmerDescriptor.cs b/src/Nest/DSL/PutWarmerDescriptor.cs
index 135e512edce..58f59abfdbb 100644
--- a/src/Nest/DSL/PutWarmerDescriptor.cs
+++ b/src/Nest/DSL/PutWarmerDescriptor.cs
@@ -15,8 +15,8 @@ namespace Nest
 	[DescriptorFor("IndicesPutWarmer")]
 	[JsonConverter(typeof(CustomJsonConverter))]
 	public partial class PutWarmerDescriptor :
-		IndicesOptionalTypesNamePathDecriptor<PutWarmerDescriptor, PutWarmerQueryString>
-		, IPathInfo<PutWarmerQueryString>
+		IndicesOptionalTypesNamePathDecriptor<PutWarmerDescriptor, PutWarmerRequestParameters>
+		, IPathInfo<PutWarmerRequestParameters>
 		, IActAsSearchDescriptor
 		, ICustomJson
 	{
@@ -29,9 +29,9 @@ public PutWarmerDescriptor Search<T>(Func<SearchDescriptor<T>, SearchDescriptor<
 			return this;
 		}
 
-		ElasticsearchPathInfo<PutWarmerQueryString> IPathInfo<PutWarmerQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<PutWarmerRequestParameters> IPathInfo<PutWarmerRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<PutWarmerQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<PutWarmerRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.PUT;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/RefreshDescriptor.cs b/src/Nest/DSL/RefreshDescriptor.cs
index c35bcb40118..12c0ebc6dd1 100644
--- a/src/Nest/DSL/RefreshDescriptor.cs
+++ b/src/Nest/DSL/RefreshDescriptor.cs
@@ -13,12 +13,12 @@
 namespace Nest
 {
 	[DescriptorFor("IndicesRefresh")]
-	public partial class RefreshDescriptor : IndicesOptionalPathDescriptor<RefreshDescriptor, RefreshQueryString>
-		, IPathInfo<RefreshQueryString>
+	public partial class RefreshDescriptor : IndicesOptionalPathDescriptor<RefreshDescriptor, RefreshRequestParameters>
+		, IPathInfo<RefreshRequestParameters>
 	{
-		ElasticsearchPathInfo<RefreshQueryString> IPathInfo<RefreshQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<RefreshRequestParameters> IPathInfo<RefreshRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<RefreshQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<RefreshRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			
 			return pathInfo;
diff --git a/src/Nest/DSL/RegisterPercolatorDescriptor.cs b/src/Nest/DSL/RegisterPercolatorDescriptor.cs
index 12c79574501..b7f3e3b87a5 100644
--- a/src/Nest/DSL/RegisterPercolatorDescriptor.cs
+++ b/src/Nest/DSL/RegisterPercolatorDescriptor.cs
@@ -12,8 +12,8 @@
 namespace Nest
 {
 
-	public class RegisterPercolatorDescriptor<T> : IndexNamePathDescriptor<RegisterPercolatorDescriptor<T>, IndexQueryString>
- 		, IPathInfo<IndexQueryString> 
+	public class RegisterPercolatorDescriptor<T> : IndexNamePathDescriptor<RegisterPercolatorDescriptor<T>, IndexRequestParameters>
+ 		, IPathInfo<IndexRequestParameters> 
 		where T : class
 	{
 		internal FluentDictionary<string, object> _RequestBody
@@ -52,13 +52,13 @@ public RegisterPercolatorDescriptor<T> Query(Func<QueryDescriptor<T>, BaseQuery>
 			return this;
 		}
 
-		ElasticsearchPathInfo<IndexQueryString> IPathInfo<IndexQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<IndexRequestParameters> IPathInfo<IndexRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
 			//registering a percolator in elasticsearch < 1.0 is actually indexing a document in a 
 			//special _percolator index where the passed index is actually a type
 			//the name is actually the id, we rectify that here
 
-			var pathInfo = base.ToPathInfo<IndexQueryString>(settings, new IndexQueryString());
+			var pathInfo = base.ToPathInfo<IndexRequestParameters>(settings, new IndexRequestParameters());
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			pathInfo.Index = pathInfo.Index;
 			pathInfo.Id = pathInfo.Name;
diff --git a/src/Nest/DSL/ScrollDescriptor.cs b/src/Nest/DSL/ScrollDescriptor.cs
index 24f4dcc11c9..22cc7d057c3 100644
--- a/src/Nest/DSL/ScrollDescriptor.cs
+++ b/src/Nest/DSL/ScrollDescriptor.cs
@@ -14,17 +14,17 @@
 namespace Nest
 {
 	public partial class ScrollDescriptor<T> :
-		IPathInfo<ScrollQueryString>,
+		IPathInfo<ScrollRequestParameters>,
 		IHideObjectMembers
 		where T : class
 	{
-		ElasticsearchPathInfo<ScrollQueryString> IPathInfo<ScrollQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<ScrollRequestParameters> IPathInfo<ScrollRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = new ElasticsearchPathInfo<ScrollQueryString>();
+			var pathInfo = new ElasticsearchPathInfo<ScrollRequestParameters>();
 			// force POST scrollId can be quite big
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			pathInfo.ScrollId = this._QueryString._scroll_id;
-			// force scroll id out of querystring (potentially very large)
+			// force scroll id out of RequestParameters (potentially very large)
 			this._QueryString._QueryStringDictionary.Remove("scroll_id");
 			pathInfo.QueryString = this._QueryString;
 			return pathInfo;
diff --git a/src/Nest/DSL/SearchDescriptor.cs b/src/Nest/DSL/SearchDescriptor.cs
index b82868edc63..e7f3d59cea5 100644
--- a/src/Nest/DSL/SearchDescriptor.cs
+++ b/src/Nest/DSL/SearchDescriptor.cs
@@ -22,7 +22,7 @@ namespace Nest
 	[JsonObject(MemberSerialization = MemberSerialization.OptIn)]
 	public partial class SearchDescriptor<T> :
 		SearchDescriptorBase
-		, IPathInfo<SearchQueryString>
+		, IPathInfo<SearchRequestParameters>
 		where T : class
 	{
 		internal override SearchTypeOptions? _SearchType
@@ -1057,9 +1057,9 @@ public SearchDescriptor<T> ConcreteTypeSelector(Func<dynamic, Hit<dynamic>, Type
 			return this;
 		}
 
-		ElasticsearchPathInfo<SearchQueryString> IPathInfo<SearchQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<SearchRequestParameters> IPathInfo<SearchRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = new ElasticsearchPathInfo<SearchQueryString>();
+			var pathInfo = new ElasticsearchPathInfo<SearchRequestParameters>();
 			pathInfo.HttpMethod = this._QueryString.ContainsKey("source")
 				? PathInfoHttpMethod.GET
 				: PathInfoHttpMethod.POST;
diff --git a/src/Nest/DSL/SegmentsDescriptor.cs b/src/Nest/DSL/SegmentsDescriptor.cs
index 3c9986fbb00..288618ded14 100644
--- a/src/Nest/DSL/SegmentsDescriptor.cs
+++ b/src/Nest/DSL/SegmentsDescriptor.cs
@@ -13,12 +13,12 @@
 namespace Nest
 {
 	[DescriptorFor("IndicesSegments")]
-	public partial class SegmentsDescriptor : IndicesOptionalPathDescriptor<SegmentsDescriptor, SegmentsQueryString>
-		, IPathInfo<SegmentsQueryString>
+	public partial class SegmentsDescriptor : IndicesOptionalPathDescriptor<SegmentsDescriptor, SegmentsRequestParameters>
+		, IPathInfo<SegmentsRequestParameters>
 	{
-		ElasticsearchPathInfo<SegmentsQueryString> IPathInfo<SegmentsQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<SegmentsRequestParameters> IPathInfo<SegmentsRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<SegmentsQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<SegmentsRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 			
 			return pathInfo;
diff --git a/src/Nest/DSL/SnapshotDescriptor.cs b/src/Nest/DSL/SnapshotDescriptor.cs
index ed640f7654a..05d2792406d 100644
--- a/src/Nest/DSL/SnapshotDescriptor.cs
+++ b/src/Nest/DSL/SnapshotDescriptor.cs
@@ -13,12 +13,12 @@
 namespace Nest
 {
 	[DescriptorFor("IndicesSnapshotIndex")]
-	public partial class SnapshotDescriptor : IndicesOptionalPathDescriptor<SnapshotDescriptor, SnapshotQueryString>
-		, IPathInfo<SnapshotQueryString>
+	public partial class SnapshotDescriptor : IndicesOptionalPathDescriptor<SnapshotDescriptor, SnapshotRequestParameters>
+		, IPathInfo<SnapshotRequestParameters>
 	{
-		ElasticsearchPathInfo<SnapshotQueryString> IPathInfo<SnapshotQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<SnapshotRequestParameters> IPathInfo<SnapshotRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<SnapshotQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<SnapshotRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/SourceDescriptor.cs b/src/Nest/DSL/SourceDescriptor.cs
index f91a226996f..80a45f2c28f 100644
--- a/src/Nest/DSL/SourceDescriptor.cs
+++ b/src/Nest/DSL/SourceDescriptor.cs
@@ -11,8 +11,8 @@
 namespace Nest
 {
 	[DescriptorFor("GetSource")]
-	public partial class SourceDescriptor<T> : DocumentPathDescriptorBase<SourceDescriptor<T>,T, SourceQueryString>
-		, IPathInfo<SourceQueryString>
+	public partial class SourceDescriptor<T> : DocumentPathDescriptorBase<SourceDescriptor<T>,T, SourceRequestParameters>
+		, IPathInfo<SourceRequestParameters>
 		where T : class
 	{
 
@@ -27,9 +27,9 @@ public SourceDescriptor<T> ExecuteOnLocalShard()
 		}
 		
 		
-		ElasticsearchPathInfo<SourceQueryString> IPathInfo<SourceQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<SourceRequestParameters> IPathInfo<SourceRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = this.ToPathInfo<SourceQueryString>(settings, this._QueryString);
+			var pathInfo = this.ToPathInfo<SourceRequestParameters>(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/UnregisterPercolatorDescriptor.cs b/src/Nest/DSL/UnregisterPercolatorDescriptor.cs
index 3c4d15b86dd..68813cd37a5 100644
--- a/src/Nest/DSL/UnregisterPercolatorDescriptor.cs
+++ b/src/Nest/DSL/UnregisterPercolatorDescriptor.cs
@@ -13,16 +13,16 @@
 namespace Nest
 {
 	public partial class UnregisterPercolatorDescriptor 
-		: IndexNamePathDescriptor<UnregisterPercolatorDescriptor, DeleteQueryString>
-		, IPathInfo<DeleteQueryString>
+		: IndexNamePathDescriptor<UnregisterPercolatorDescriptor, DeleteRequestParameters>
+		, IPathInfo<DeleteRequestParameters>
 	{
-		ElasticsearchPathInfo<DeleteQueryString> IPathInfo<DeleteQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<DeleteRequestParameters> IPathInfo<DeleteRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
 			//deleting a percolator in elasticsearch < 1.0 is actually deleting a document in a 
 			//special _percolator index where the passed index is actually a type
 			//the name is actually the id, we rectify that here
 
-			var pathInfo = base.ToPathInfo<DeleteQueryString>(settings, new DeleteQueryString());
+			var pathInfo = base.ToPathInfo<DeleteRequestParameters>(settings, new DeleteRequestParameters());
 			pathInfo.Index = pathInfo.Index;
 			pathInfo.Id = pathInfo.Name;
 			pathInfo.Type = ".percolator";
diff --git a/src/Nest/DSL/UpdateDescriptor.cs b/src/Nest/DSL/UpdateDescriptor.cs
index 5708df3c1ff..328308fcb94 100644
--- a/src/Nest/DSL/UpdateDescriptor.cs
+++ b/src/Nest/DSL/UpdateDescriptor.cs
@@ -9,8 +9,8 @@
 
 namespace Nest
 {
-	public partial class UpdateDescriptor<T,K> : DocumentPathDescriptorBase<UpdateDescriptor<T, K>, T, UpdateQueryString> 
-		, IPathInfo<UpdateQueryString> 
+	public partial class UpdateDescriptor<T,K> : DocumentPathDescriptorBase<UpdateDescriptor<T, K>, T, UpdateRequestParameters> 
+		, IPathInfo<UpdateRequestParameters> 
 		where T : class 
 		where K : class
 	{
@@ -80,9 +80,9 @@ public UpdateDescriptor<T, K> DocAsUpsert(bool docAsUpsert = true)
 			return this;
 		}
 
-		ElasticsearchPathInfo<UpdateQueryString> IPathInfo<UpdateQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<UpdateRequestParameters> IPathInfo<UpdateRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<UpdateQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<UpdateRequestParameters>(settings, this._QueryString);
 			pathInfo.QueryString = this._QueryString;
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			
diff --git a/src/Nest/DSL/UpdateSettingsDescriptor.cs b/src/Nest/DSL/UpdateSettingsDescriptor.cs
index fd1aa6880e5..656522088f2 100644
--- a/src/Nest/DSL/UpdateSettingsDescriptor.cs
+++ b/src/Nest/DSL/UpdateSettingsDescriptor.cs
@@ -12,8 +12,8 @@ namespace Nest
 {
 	[DescriptorFor("IndicesPutSettings")]
 	public partial class UpdateSettingsDescriptor
-		: IndexOptionalPathDescriptorBase<UpdateSettingsDescriptor, UpdateSettingsQueryString>
-		, IPathInfo<UpdateSettingsQueryString>
+		: IndexOptionalPathDescriptorBase<UpdateSettingsDescriptor, UpdateSettingsRequestParameters>
+		, IPathInfo<UpdateSettingsRequestParameters>
 	{
 		[JsonProperty("index.number_of_replicas")]
 		internal int? _NumberOfReplicas { get; set; }
@@ -396,9 +396,9 @@ public UpdateSettingsDescriptor Analysis(Func<AnalysisDescriptor, AnalysisDescri
 			return this;
 		}
 
-		ElasticsearchPathInfo<UpdateSettingsQueryString> IPathInfo<UpdateSettingsQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<UpdateSettingsRequestParameters> IPathInfo<UpdateSettingsRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<UpdateSettingsQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<UpdateSettingsRequestParameters>(settings, this._QueryString);
 			pathInfo.QueryString = this._QueryString;
 			pathInfo.HttpMethod = PathInfoHttpMethod.PUT;
 
diff --git a/src/Nest/DSL/ValidateQueryDescriptor.cs b/src/Nest/DSL/ValidateQueryDescriptor.cs
index 4d056971d46..709bdb33e6c 100644
--- a/src/Nest/DSL/ValidateQueryDescriptor.cs
+++ b/src/Nest/DSL/ValidateQueryDescriptor.cs
@@ -7,8 +7,8 @@ namespace Nest
 {
 	[DescriptorFor("IndicesValidateQuery")]
 	public partial class ValidateQueryDescriptor<T> 
-		:	QueryPathDescriptorBase<ValidateQueryDescriptor<T>, T, ValidateQueryQueryString>
-		, IPathInfo<ValidateQueryQueryString> 
+		:	QueryPathDescriptorBase<ValidateQueryDescriptor<T>, T, ValidateQueryRequestParameters>
+		, IPathInfo<ValidateQueryRequestParameters> 
 		where T : class
 	{
 		[JsonProperty("query")]
@@ -20,9 +20,9 @@ public ValidateQueryDescriptor<T> Query(Func<QueryDescriptor<T>, BaseQuery> quer
 			return this;
 		}
 
-		ElasticsearchPathInfo<ValidateQueryQueryString> IPathInfo<ValidateQueryQueryString>.ToPathInfo(IConnectionSettingsValues settings)
+		ElasticsearchPathInfo<ValidateQueryRequestParameters> IPathInfo<ValidateQueryRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<ValidateQueryQueryString>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo<ValidateQueryRequestParameters>(settings, this._QueryString);
 			pathInfo.QueryString = this._QueryString;
 			var qs = this._QueryString;
 			pathInfo.HttpMethod = (!qs._source.IsNullOrEmpty() || !qs._q.IsNullOrEmpty())
diff --git a/src/Nest/DSL/_Descriptors.generated.cs b/src/Nest/DSL/_Descriptors.generated.cs
index f968ee8b20b..7ef8573adc5 100644
--- a/src/Nest/DSL/_Descriptors.generated.cs
+++ b/src/Nest/DSL/_Descriptors.generated.cs
@@ -7,7 +7,6 @@
 ///This file lays the base for all the descriptors based on the query string parameters in the spec for IElasticClient.
 ///This file is automatically generated from https://github.com/elasticsearch/elasticsearch-rest-api-spec
 ///Generated of commit 
-using Nest.Domain;
 
 namespace Nest
 {
@@ -19,7 +18,7 @@ namespace Nest
 	///</summary>
 	public partial class BulkDescriptor
 	{
-		internal BulkQueryString _QueryString = new BulkQueryString(); 
+		internal BulkRequestParameters _QueryString = new BulkRequestParameters(); 
 
 
 		///<summary>Explicit write consistency setting for the operation</summary>
@@ -80,7 +79,7 @@ public BulkDescriptor TypeQueryString(string type)
 	///</summary>
 	public partial class CatAliasesDescriptor
 	{
-		internal CatAliasesQueryString _QueryString = new CatAliasesQueryString(); 
+		internal CatAliasesRequestParameters _QueryString = new CatAliasesRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -133,7 +132,7 @@ public CatAliasesDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatAllocationDescriptor
 	{
-		internal CatAllocationQueryString _QueryString = new CatAllocationQueryString(); 
+		internal CatAllocationRequestParameters _QueryString = new CatAllocationRequestParameters(); 
 
 
 		///<summary>The unit in which to display byte values</summary>
@@ -194,7 +193,7 @@ public CatAllocationDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatCountDescriptor
 	{
-		internal CatCountQueryString _QueryString = new CatCountQueryString(); 
+		internal CatCountRequestParameters _QueryString = new CatCountRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -247,7 +246,7 @@ public CatCountDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatHealthDescriptor
 	{
-		internal CatHealthQueryString _QueryString = new CatHealthQueryString(); 
+		internal CatHealthRequestParameters _QueryString = new CatHealthRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -308,7 +307,7 @@ public CatHealthDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatHelpDescriptor
 	{
-		internal CatHelpQueryString _QueryString = new CatHelpQueryString(); 
+		internal CatHelpRequestParameters _QueryString = new CatHelpRequestParameters(); 
 
 
 		///<summary>Return help information</summary>
@@ -329,7 +328,7 @@ public CatHelpDescriptor Help(bool help = true)
 	///</summary>
 	public partial class CatIndicesDescriptor
 	{
-		internal CatIndicesQueryString _QueryString = new CatIndicesQueryString(); 
+		internal CatIndicesRequestParameters _QueryString = new CatIndicesRequestParameters(); 
 
 
 		///<summary>The unit in which to display byte values</summary>
@@ -398,7 +397,7 @@ public CatIndicesDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatMasterDescriptor
 	{
-		internal CatMasterQueryString _QueryString = new CatMasterQueryString(); 
+		internal CatMasterRequestParameters _QueryString = new CatMasterRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -451,7 +450,7 @@ public CatMasterDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatNodesDescriptor
 	{
-		internal CatNodesQueryString _QueryString = new CatNodesQueryString(); 
+		internal CatNodesRequestParameters _QueryString = new CatNodesRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -504,7 +503,7 @@ public CatNodesDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatPendingTasksDescriptor
 	{
-		internal CatPendingTasksQueryString _QueryString = new CatPendingTasksQueryString(); 
+		internal CatPendingTasksRequestParameters _QueryString = new CatPendingTasksRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -557,7 +556,7 @@ public CatPendingTasksDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatRecoveryDescriptor
 	{
-		internal CatRecoveryQueryString _QueryString = new CatRecoveryQueryString(); 
+		internal CatRecoveryRequestParameters _QueryString = new CatRecoveryRequestParameters(); 
 
 
 		///<summary>The unit in which to display byte values</summary>
@@ -618,7 +617,7 @@ public CatRecoveryDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatShardsDescriptor
 	{
-		internal CatShardsQueryString _QueryString = new CatShardsQueryString(); 
+		internal CatShardsRequestParameters _QueryString = new CatShardsRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -671,7 +670,7 @@ public CatShardsDescriptor V(bool v = true)
 	///</summary>
 	public partial class CatThreadPoolDescriptor
 	{
-		internal CatThreadPoolQueryString _QueryString = new CatThreadPoolQueryString(); 
+		internal CatThreadPoolRequestParameters _QueryString = new CatThreadPoolRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -732,7 +731,7 @@ public CatThreadPoolDescriptor FullId(bool full_id = true)
 	///</summary>
 	public partial class ClearScrollDescriptor
 	{
-		internal ClearScrollQueryString _QueryString = new ClearScrollQueryString(); 
+		internal ClearScrollRequestParameters _QueryString = new ClearScrollRequestParameters(); 
 
 		
 	}
@@ -745,7 +744,7 @@ public partial class ClearScrollDescriptor
 	///</summary>
 	public partial class ClusterGetSettingsDescriptor
 	{
-		internal ClusterGetSettingsQueryString _QueryString = new ClusterGetSettingsQueryString(); 
+		internal ClusterGetSettingsRequestParameters _QueryString = new ClusterGetSettingsRequestParameters(); 
 
 
 		///<summary>Return settings in flat format (default: false)</summary>
@@ -782,7 +781,7 @@ public ClusterGetSettingsDescriptor Timeout(string timeout)
 	///</summary>
 	public partial class ClusterHealthDescriptor
 	{
-		internal ClusterHealthQueryString _QueryString = new ClusterHealthQueryString(); 
+		internal ClusterHealthRequestParameters _QueryString = new ClusterHealthRequestParameters(); 
 
 
 		///<summary>Specify the level of detail for returned information</summary>
@@ -859,7 +858,7 @@ public ClusterHealthDescriptor WaitForStatus(WaitForStatusOptions wait_for_statu
 	///</summary>
 	public partial class ClusterPendingTasksDescriptor
 	{
-		internal ClusterPendingTasksQueryString _QueryString = new ClusterPendingTasksQueryString(); 
+		internal ClusterPendingTasksRequestParameters _QueryString = new ClusterPendingTasksRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -888,7 +887,7 @@ public ClusterPendingTasksDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class ClusterPutSettingsDescriptor
 	{
-		internal ClusterPutSettingsQueryString _QueryString = new ClusterPutSettingsQueryString(); 
+		internal ClusterPutSettingsRequestParameters _QueryString = new ClusterPutSettingsRequestParameters(); 
 
 
 		///<summary>Return settings in flat format (default: false)</summary>
@@ -909,7 +908,7 @@ public ClusterPutSettingsDescriptor FlatSettings(bool flat_settings = true)
 	///</summary>
 	public partial class ClusterRerouteDescriptor
 	{
-		internal ClusterRerouteQueryString _QueryString = new ClusterRerouteQueryString(); 
+		internal ClusterRerouteRequestParameters _QueryString = new ClusterRerouteRequestParameters(); 
 
 
 		///<summary>Simulate the operation only and return the resulting state</summary>
@@ -954,7 +953,7 @@ public ClusterRerouteDescriptor Timeout(string timeout)
 	///</summary>
 	public partial class ClusterStateDescriptor
 	{
-		internal ClusterStateQueryString _QueryString = new ClusterStateQueryString(); 
+		internal ClusterStateRequestParameters _QueryString = new ClusterStateRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -999,7 +998,7 @@ public ClusterStateDescriptor FlatSettings(bool flat_settings = true)
 	///</summary>
 	public partial class ClusterStatsDescriptor
 	{
-		internal ClusterStatsQueryString _QueryString = new ClusterStatsQueryString(); 
+		internal ClusterStatsRequestParameters _QueryString = new ClusterStatsRequestParameters(); 
 
 
 		///<summary>Return settings in flat format (default: false)</summary>
@@ -1028,7 +1027,7 @@ public ClusterStatsDescriptor Human(bool human = true)
 	///</summary>
 	public partial class CountDescriptor<T>
 	{
-		internal CountQueryString _QueryString = new CountQueryString(); 
+		internal CountRequestParameters _QueryString = new CountRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -1097,7 +1096,7 @@ public CountDescriptor<T> Source(string source)
 	///</summary>
 	public partial class CountPercolateDescriptor
 	{
-		internal CountPercolateQueryString _QueryString = new CountPercolateQueryString(); 
+		internal CountPercolateRequestParameters _QueryString = new CountPercolateRequestParameters(); 
 
 
 		///<summary>A comma-separated list of specific routing values</summary>
@@ -1182,7 +1181,7 @@ public CountPercolateDescriptor VersionType(VersionTypeOptions version_type)
 	///</summary>
 	public partial class DeleteDescriptor<T>
 	{
-		internal DeleteQueryString _QueryString = new DeleteQueryString(); 
+		internal DeleteRequestParameters _QueryString = new DeleteRequestParameters(); 
 
 
 		///<summary>Specific write consistency setting for the operation</summary>
@@ -1259,7 +1258,7 @@ public DeleteDescriptor<T> VersionType(VersionTypeOptions version_type)
 	///</summary>
 	public partial class DeleteByQueryDescriptor<T>
 	{
-		internal DeleteByQueryQueryString _QueryString = new DeleteByQueryQueryString(); 
+		internal DeleteByQueryRequestParameters _QueryString = new DeleteByQueryRequestParameters(); 
 
 
 		///<summary>The analyzer to use for the query string</summary>
@@ -1368,7 +1367,7 @@ public DeleteByQueryDescriptor<T> Timeout(string timeout)
 	///</summary>
 	public partial class ExistsDescriptor
 	{
-		internal ExistsQueryString _QueryString = new ExistsQueryString(); 
+		internal ExistsRequestParameters _QueryString = new ExistsRequestParameters(); 
 
 
 		///<summary>The ID of the parent document</summary>
@@ -1421,7 +1420,7 @@ public ExistsDescriptor Routing(string routing)
 	///</summary>
 	public partial class ExplainDescriptor
 	{
-		internal ExplainQueryString _QueryString = new ExplainQueryString(); 
+		internal ExplainRequestParameters _QueryString = new ExplainRequestParameters(); 
 
 
 		///<summary>Specify whether wildcards and prefix queries in the query string query should be analyzed (default: false)</summary>
@@ -1587,7 +1586,7 @@ public ExplainDescriptor SourceInclude<T>(params Expression<Func<T, object>>[] t
 	///</summary>
 	public partial class GetDescriptor<T>
 	{
-		internal GetQueryString _QueryString = new GetQueryString(); 
+		internal GetRequestParameters _QueryString = new GetRequestParameters(); 
 
 
 		///<summary>A comma-separated list of fields to return in the response</summary>
@@ -1721,7 +1720,7 @@ public GetDescriptor<T> VersionType(VersionTypeOptions version_type)
 	///</summary>
 	public partial class SourceDescriptor<T>
 	{
-		internal SourceQueryString _QueryString = new SourceQueryString(); 
+		internal SourceRequestParameters _QueryString = new SourceRequestParameters(); 
 
 
 		///<summary>The ID of the parent document</summary>
@@ -1836,7 +1835,7 @@ public SourceDescriptor<T> VersionType(VersionTypeOptions version_type)
 	///</summary>
 	public partial class IndexDescriptor<T>
 	{
-		internal IndexQueryString _QueryString = new IndexQueryString(); 
+		internal IndexRequestParameters _QueryString = new IndexRequestParameters(); 
 
 
 		///<summary>Explicit write consistency setting for the operation</summary>
@@ -1937,7 +1936,7 @@ public IndexDescriptor<T> VersionType(VersionTypeOptions version_type)
 	///</summary>
 	public partial class AnalyzeDescriptor
 	{
-		internal AnalyzeQueryString _QueryString = new AnalyzeQueryString(); 
+		internal AnalyzeRequestParameters _QueryString = new AnalyzeRequestParameters(); 
 
 
 		///<summary>The name of the analyzer to use</summary>
@@ -2023,7 +2022,7 @@ public AnalyzeDescriptor Format(FormatOptions format)
 	///</summary>
 	public partial class ClearCacheDescriptor
 	{
-		internal ClearCacheQueryString _QueryString = new ClearCacheQueryString(); 
+		internal ClearCacheRequestParameters _QueryString = new ClearCacheRequestParameters(); 
 
 
 		///<summary>Clear field data</summary>
@@ -2151,7 +2150,7 @@ public ClearCacheDescriptor Recycler(bool recycler = true)
 	///</summary>
 	public partial class CloseIndexDescriptor
 	{
-		internal CloseIndexQueryString _QueryString = new CloseIndexQueryString(); 
+		internal CloseIndexRequestParameters _QueryString = new CloseIndexRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout</summary>
@@ -2204,7 +2203,7 @@ public CloseIndexDescriptor ExpandWildcards(ExpandWildcardsOptions expand_wildca
 	///</summary>
 	public partial class CreateIndexDescriptor
 	{
-		internal CreateIndexQueryString _QueryString = new CreateIndexQueryString(); 
+		internal CreateIndexRequestParameters _QueryString = new CreateIndexRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout</summary>
@@ -2233,7 +2232,7 @@ public CreateIndexDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class DeleteIndexDescriptor
 	{
-		internal DeleteIndexQueryString _QueryString = new DeleteIndexQueryString(); 
+		internal DeleteIndexRequestParameters _QueryString = new DeleteIndexRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout</summary>
@@ -2262,7 +2261,7 @@ public DeleteIndexDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class IndicesDeleteAliasDescriptor
 	{
-		internal IndicesDeleteAliasQueryString _QueryString = new IndicesDeleteAliasQueryString(); 
+		internal IndicesDeleteAliasRequestParameters _QueryString = new IndicesDeleteAliasRequestParameters(); 
 
 
 		///<summary>Explicit timestamp for the document</summary>
@@ -2291,7 +2290,7 @@ public IndicesDeleteAliasDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class DeleteMappingDescriptor
 	{
-		internal DeleteMappingQueryString _QueryString = new DeleteMappingQueryString(); 
+		internal DeleteMappingRequestParameters _QueryString = new DeleteMappingRequestParameters(); 
 
 
 		///<summary>Specify timeout for connection to master</summary>
@@ -2312,7 +2311,7 @@ public DeleteMappingDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class DeleteTemplateDescriptor
 	{
-		internal DeleteTemplateQueryString _QueryString = new DeleteTemplateQueryString(); 
+		internal DeleteTemplateRequestParameters _QueryString = new DeleteTemplateRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout</summary>
@@ -2341,7 +2340,7 @@ public DeleteTemplateDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class DeleteWarmerDescriptor
 	{
-		internal DeleteWarmerQueryString _QueryString = new DeleteWarmerQueryString(); 
+		internal DeleteWarmerRequestParameters _QueryString = new DeleteWarmerRequestParameters(); 
 
 
 		///<summary>Specify timeout for connection to master</summary>
@@ -2362,7 +2361,7 @@ public DeleteWarmerDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class IndexExistsDescriptor
 	{
-		internal IndexExistsQueryString _QueryString = new IndexExistsQueryString(); 
+		internal IndexExistsRequestParameters _QueryString = new IndexExistsRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -2407,7 +2406,7 @@ public IndexExistsDescriptor Local(bool local = true)
 	///</summary>
 	public partial class IndicesExistsAliasDescriptor
 	{
-		internal IndicesExistsAliasQueryString _QueryString = new IndicesExistsAliasQueryString(); 
+		internal IndicesExistsAliasRequestParameters _QueryString = new IndicesExistsAliasRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -2452,7 +2451,7 @@ public IndicesExistsAliasDescriptor Local(bool local = true)
 	///</summary>
 	public partial class IndicesExistsTemplateDescriptor
 	{
-		internal IndicesExistsTemplateQueryString _QueryString = new IndicesExistsTemplateQueryString(); 
+		internal IndicesExistsTemplateRequestParameters _QueryString = new IndicesExistsTemplateRequestParameters(); 
 
 
 		///<summary>Return local information, do not retrieve the state from master node (default: false)</summary>
@@ -2473,7 +2472,7 @@ public IndicesExistsTemplateDescriptor Local(bool local = true)
 	///</summary>
 	public partial class IndicesExistsTypeDescriptor
 	{
-		internal IndicesExistsTypeQueryString _QueryString = new IndicesExistsTypeQueryString(); 
+		internal IndicesExistsTypeRequestParameters _QueryString = new IndicesExistsTypeRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -2518,7 +2517,7 @@ public IndicesExistsTypeDescriptor Local(bool local = true)
 	///</summary>
 	public partial class FlushDescriptor
 	{
-		internal FlushQueryString _QueryString = new FlushQueryString(); 
+		internal FlushRequestParameters _QueryString = new FlushRequestParameters(); 
 
 
 		///<summary>Whether a flush should be forced even if it is not necessarily needed ie. if no changes will be committed to the index. This is useful if transaction log IDs should be incremented even if no uncommitted changes are present. (This setting can be considered as internal)</summary>
@@ -2571,7 +2570,7 @@ public FlushDescriptor ExpandWildcards(ExpandWildcardsOptions expand_wildcards)
 	///</summary>
 	public partial class GetAliasesDescriptor
 	{
-		internal GetAliasesQueryString _QueryString = new GetAliasesQueryString(); 
+		internal GetAliasesRequestParameters _QueryString = new GetAliasesRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -2616,7 +2615,7 @@ public GetAliasesDescriptor Local(bool local = true)
 	///</summary>
 	public partial class IndicesGetAliasesDescriptor
 	{
-		internal IndicesGetAliasesQueryString _QueryString = new IndicesGetAliasesQueryString(); 
+		internal IndicesGetAliasesRequestParameters _QueryString = new IndicesGetAliasesRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout</summary>
@@ -2645,7 +2644,7 @@ public IndicesGetAliasesDescriptor Local(bool local = true)
 	///</summary>
 	public partial class IndicesGetFieldMappingDescriptor
 	{
-		internal IndicesGetFieldMappingQueryString _QueryString = new IndicesGetFieldMappingQueryString(); 
+		internal IndicesGetFieldMappingRequestParameters _QueryString = new IndicesGetFieldMappingRequestParameters(); 
 
 
 		///<summary>Whether the default mapping values should be returned as well</summary>
@@ -2698,7 +2697,7 @@ public IndicesGetFieldMappingDescriptor Local(bool local = true)
 	///</summary>
 	public partial class GetMappingDescriptor
 	{
-		internal GetMappingQueryString _QueryString = new GetMappingQueryString(); 
+		internal GetMappingRequestParameters _QueryString = new GetMappingRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -2743,7 +2742,7 @@ public GetMappingDescriptor Local(bool local = true)
 	///</summary>
 	public partial class GetIndexSettingsDescriptor
 	{
-		internal GetIndexSettingsQueryString _QueryString = new GetIndexSettingsQueryString(); 
+		internal GetIndexSettingsRequestParameters _QueryString = new GetIndexSettingsRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -2796,7 +2795,7 @@ public GetIndexSettingsDescriptor Local(bool local = true)
 	///</summary>
 	public partial class GetTemplateDescriptor
 	{
-		internal GetTemplateQueryString _QueryString = new GetTemplateQueryString(); 
+		internal GetTemplateRequestParameters _QueryString = new GetTemplateRequestParameters(); 
 
 
 		///<summary>Return settings in flat format (default: false)</summary>
@@ -2825,7 +2824,7 @@ public GetTemplateDescriptor Local(bool local = true)
 	///</summary>
 	public partial class GetWarmerDescriptor
 	{
-		internal GetWarmerQueryString _QueryString = new GetWarmerQueryString(); 
+		internal GetWarmerRequestParameters _QueryString = new GetWarmerRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -2870,7 +2869,7 @@ public GetWarmerDescriptor Local(bool local = true)
 	///</summary>
 	public partial class OpenIndexDescriptor
 	{
-		internal OpenIndexQueryString _QueryString = new OpenIndexQueryString(); 
+		internal OpenIndexRequestParameters _QueryString = new OpenIndexRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout</summary>
@@ -2923,7 +2922,7 @@ public OpenIndexDescriptor ExpandWildcards(ExpandWildcardsOptions expand_wildcar
 	///</summary>
 	public partial class OptimizeDescriptor
 	{
-		internal OptimizeQueryString _QueryString = new OptimizeQueryString(); 
+		internal OptimizeRequestParameters _QueryString = new OptimizeRequestParameters(); 
 
 
 		///<summary>Specify whether the index should be flushed after performing the operation (default: true)</summary>
@@ -3000,7 +2999,7 @@ public OptimizeDescriptor WaitForMerge(bool wait_for_merge = true)
 	///</summary>
 	public partial class IndicesPutAliasDescriptor
 	{
-		internal IndicesPutAliasQueryString _QueryString = new IndicesPutAliasQueryString(); 
+		internal IndicesPutAliasRequestParameters _QueryString = new IndicesPutAliasRequestParameters(); 
 
 
 		///<summary>Explicit timestamp for the document</summary>
@@ -3029,7 +3028,7 @@ public IndicesPutAliasDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class PutMappingDescriptor<T>
 	{
-		internal PutMappingQueryString _QueryString = new PutMappingQueryString(); 
+		internal PutMappingRequestParameters _QueryString = new PutMappingRequestParameters(); 
 
 
 		///<summary>Specify whether to ignore conflicts while updating the mapping (default: false)</summary>
@@ -3090,7 +3089,7 @@ public PutMappingDescriptor<T> ExpandWildcards(ExpandWildcardsOptions expand_wil
 	///</summary>
 	public partial class UpdateSettingsDescriptor
 	{
-		internal UpdateSettingsQueryString _QueryString = new UpdateSettingsQueryString(); 
+		internal UpdateSettingsRequestParameters _QueryString = new UpdateSettingsRequestParameters(); 
 
 
 		///<summary>Specify timeout for connection to master</summary>
@@ -3143,7 +3142,7 @@ public UpdateSettingsDescriptor FlatSettings(bool flat_settings = true)
 	///</summary>
 	public partial class PutTemplateDescriptor
 	{
-		internal PutTemplateQueryString _QueryString = new PutTemplateQueryString(); 
+		internal PutTemplateRequestParameters _QueryString = new PutTemplateRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout</summary>
@@ -3180,7 +3179,7 @@ public PutTemplateDescriptor FlatSettings(bool flat_settings = true)
 	///</summary>
 	public partial class PutWarmerDescriptor
 	{
-		internal PutWarmerQueryString _QueryString = new PutWarmerQueryString(); 
+		internal PutWarmerRequestParameters _QueryString = new PutWarmerRequestParameters(); 
 
 
 		///<summary>Specify timeout for connection to master</summary>
@@ -3225,7 +3224,7 @@ public PutWarmerDescriptor ExpandWildcards(ExpandWildcardsOptions expand_wildcar
 	///</summary>
 	public partial class RefreshDescriptor
 	{
-		internal RefreshQueryString _QueryString = new RefreshQueryString(); 
+		internal RefreshRequestParameters _QueryString = new RefreshRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -3278,7 +3277,7 @@ public RefreshDescriptor OperationThreading(string operation_threading)
 	///</summary>
 	public partial class SegmentsDescriptor
 	{
-		internal SegmentsQueryString _QueryString = new SegmentsQueryString(); 
+		internal SegmentsRequestParameters _QueryString = new SegmentsRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -3331,7 +3330,7 @@ public SegmentsDescriptor OperationThreading(string operation_threading)
 	///</summary>
 	public partial class SnapshotDescriptor
 	{
-		internal SnapshotQueryString _QueryString = new SnapshotQueryString(); 
+		internal SnapshotRequestParameters _QueryString = new SnapshotRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -3368,7 +3367,7 @@ public SnapshotDescriptor ExpandWildcards(ExpandWildcardsOptions expand_wildcard
 	///</summary>
 	public partial class IndicesStatsDescriptor
 	{
-		internal IndicesStatsQueryString _QueryString = new IndicesStatsQueryString(); 
+		internal IndicesStatsRequestParameters _QueryString = new IndicesStatsRequestParameters(); 
 
 
 		///<summary>A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)</summary>
@@ -3470,7 +3469,7 @@ public IndicesStatsDescriptor Types(params string[] types)
 	///</summary>
 	public partial class IndicesStatusDescriptor
 	{
-		internal IndicesStatusQueryString _QueryString = new IndicesStatusQueryString(); 
+		internal IndicesStatusRequestParameters _QueryString = new IndicesStatusRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -3539,7 +3538,7 @@ public IndicesStatusDescriptor Snapshot(bool snapshot = true)
 	///</summary>
 	public partial class AliasDescriptor
 	{
-		internal AliasQueryString _QueryString = new AliasQueryString(); 
+		internal AliasRequestParameters _QueryString = new AliasRequestParameters(); 
 
 
 		///<summary>Request timeout</summary>
@@ -3568,7 +3567,7 @@ public AliasDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class ValidateQueryDescriptor<T>
 	{
-		internal ValidateQueryQueryString _QueryString = new ValidateQueryQueryString(); 
+		internal ValidateQueryRequestParameters _QueryString = new ValidateQueryRequestParameters(); 
 
 
 		///<summary>Return detailed information about the error</summary>
@@ -3637,7 +3636,7 @@ public ValidateQueryDescriptor<T> Q(string q)
 	///</summary>
 	public partial class InfoDescriptor
 	{
-		internal InfoQueryString _QueryString = new InfoQueryString(); 
+		internal InfoRequestParameters _QueryString = new InfoRequestParameters(); 
 
 		
 	}
@@ -3650,7 +3649,7 @@ public partial class InfoDescriptor
 	///</summary>
 	public partial class MultiGetDescriptor
 	{
-		internal MultiGetQueryString _QueryString = new MultiGetQueryString(); 
+		internal MultiGetRequestParameters _QueryString = new MultiGetRequestParameters(); 
 
 
 		///<summary>A comma-separated list of fields to return in the response</summary>
@@ -3752,7 +3751,7 @@ public MultiGetDescriptor SourceInclude<T>(params Expression<Func<T, object>>[]
 	///</summary>
 	public partial class MoreLikeThisDescriptor<T>
 	{
-		internal MoreLikeThisQueryString _QueryString = new MoreLikeThisQueryString(); 
+		internal MoreLikeThisRequestParameters _QueryString = new MoreLikeThisRequestParameters(); 
 
 
 		///<summary>The boost factor</summary>
@@ -3928,7 +3927,7 @@ public MoreLikeThisDescriptor<T> StopWords(params string[] stop_words)
 	///</summary>
 	public partial class MpercolateDescriptor
 	{
-		internal MpercolateQueryString _QueryString = new MpercolateQueryString(); 
+		internal MpercolateRequestParameters _QueryString = new MpercolateRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -3965,7 +3964,7 @@ public MpercolateDescriptor ExpandWildcards(ExpandWildcardsOptions expand_wildca
 	///</summary>
 	public partial class MultiSearchDescriptor
 	{
-		internal MultiSearchQueryString _QueryString = new MultiSearchQueryString(); 
+		internal MultiSearchRequestParameters _QueryString = new MultiSearchRequestParameters(); 
 
 
 		///<summary>Search operation type</summary>
@@ -3986,7 +3985,7 @@ public MultiSearchDescriptor SearchType(SearchTypeOptions search_type)
 	///</summary>
 	public partial class MtermvectorsDescriptor
 	{
-		internal MtermvectorsQueryString _QueryString = new MtermvectorsQueryString(); 
+		internal MtermvectorsRequestParameters _QueryString = new MtermvectorsRequestParameters(); 
 
 
 		///<summary>A comma-separated list of documents ids. You must define ids as parameter or set &quot;ids&quot; or &quot;docs&quot; in the request body</summary>
@@ -4090,7 +4089,7 @@ public MtermvectorsDescriptor Parent(string parent)
 	///</summary>
 	public partial class NodesHotThreadsDescriptor
 	{
-		internal NodesHotThreadsQueryString _QueryString = new NodesHotThreadsQueryString(); 
+		internal NodesHotThreadsRequestParameters _QueryString = new NodesHotThreadsRequestParameters(); 
 
 
 		///<summary>The interval for the second sampling of threads</summary>
@@ -4135,7 +4134,7 @@ public NodesHotThreadsDescriptor TypeQueryString(TypeOptions type)
 	///</summary>
 	public partial class NodesInfoDescriptor
 	{
-		internal NodesInfoQueryString _QueryString = new NodesInfoQueryString(); 
+		internal NodesInfoRequestParameters _QueryString = new NodesInfoRequestParameters(); 
 
 
 		///<summary>Return settings in flat format (default: false)</summary>
@@ -4164,7 +4163,7 @@ public NodesInfoDescriptor Human(bool human = true)
 	///</summary>
 	public partial class NodesShutdownDescriptor
 	{
-		internal NodesShutdownQueryString _QueryString = new NodesShutdownQueryString(); 
+		internal NodesShutdownRequestParameters _QueryString = new NodesShutdownRequestParameters(); 
 
 
 		///<summary>Set the delay for the operation (default: 1s)</summary>
@@ -4193,7 +4192,7 @@ public NodesShutdownDescriptor Exit(bool exit = true)
 	///</summary>
 	public partial class NodesStatsDescriptor
 	{
-		internal NodesStatsQueryString _QueryString = new NodesStatsQueryString(); 
+		internal NodesStatsRequestParameters _QueryString = new NodesStatsRequestParameters(); 
 
 
 		///<summary>A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)</summary>
@@ -4295,7 +4294,7 @@ public NodesStatsDescriptor Types(params string[] types)
 	///</summary>
 	public partial class PercolateDescriptor<T,K>
 	{
-		internal PercolateQueryString _QueryString = new PercolateQueryString(); 
+		internal PercolateRequestParameters _QueryString = new PercolateRequestParameters(); 
 
 
 		///<summary>A comma-separated list of specific routing values</summary>
@@ -4380,7 +4379,7 @@ public PercolateDescriptor<T,K> VersionType(VersionTypeOptions version_type)
 	///</summary>
 	public partial class PingDescriptor
 	{
-		internal PingQueryString _QueryString = new PingQueryString(); 
+		internal PingRequestParameters _QueryString = new PingRequestParameters(); 
 
 		
 	}
@@ -4391,9 +4390,9 @@ public partial class PingDescriptor
 	///http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html
 	///</pre>
 	///</summary>
-	public partial class ScrollDescriptor<T> : IHideObjectMembers
+	public partial class ScrollDescriptor<T>
 	{
-		internal ScrollQueryString _QueryString = new ScrollQueryString(); 
+		internal ScrollRequestParameters _QueryString = new ScrollRequestParameters(); 
 
 
 		///<summary>Specify how long a consistent view of the index should be maintained for scrolled search</summary>
@@ -4422,7 +4421,7 @@ public ScrollDescriptor<T> ScrollId(string scroll_id)
 	///</summary>
 	public partial class SearchDescriptor<T>
 	{
-		internal SearchQueryString _QueryString = new SearchQueryString(); 
+		internal SearchRequestParameters _QueryString = new SearchRequestParameters(); 
 
 
 		///<summary>The analyzer to use for the query string</summary>
@@ -4604,7 +4603,7 @@ public SearchDescriptor<T> SuggestText(string suggest_text)
 	///</summary>
 	public partial class SnapshotCreateDescriptor
 	{
-		internal SnapshotCreateQueryString _QueryString = new SnapshotCreateQueryString(); 
+		internal SnapshotCreateRequestParameters _QueryString = new SnapshotCreateRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout for connection to master node</summary>
@@ -4633,7 +4632,7 @@ public SnapshotCreateDescriptor WaitForCompletion(bool wait_for_completion = tru
 	///</summary>
 	public partial class SnapshotCreateRepositoryDescriptor
 	{
-		internal SnapshotCreateRepositoryQueryString _QueryString = new SnapshotCreateRepositoryQueryString(); 
+		internal SnapshotCreateRepositoryRequestParameters _QueryString = new SnapshotCreateRepositoryRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout for connection to master node</summary>
@@ -4662,7 +4661,7 @@ public SnapshotCreateRepositoryDescriptor Timeout(string timeout)
 	///</summary>
 	public partial class SnapshotDeleteDescriptor
 	{
-		internal SnapshotDeleteQueryString _QueryString = new SnapshotDeleteQueryString(); 
+		internal SnapshotDeleteRequestParameters _QueryString = new SnapshotDeleteRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout for connection to master node</summary>
@@ -4683,7 +4682,7 @@ public SnapshotDeleteDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class SnapshotDeleteRepositoryDescriptor
 	{
-		internal SnapshotDeleteRepositoryQueryString _QueryString = new SnapshotDeleteRepositoryQueryString(); 
+		internal SnapshotDeleteRepositoryRequestParameters _QueryString = new SnapshotDeleteRepositoryRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout for connection to master node</summary>
@@ -4712,7 +4711,7 @@ public SnapshotDeleteRepositoryDescriptor Timeout(string timeout)
 	///</summary>
 	public partial class SnapshotGetDescriptor
 	{
-		internal SnapshotGetQueryString _QueryString = new SnapshotGetQueryString(); 
+		internal SnapshotGetRequestParameters _QueryString = new SnapshotGetRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout for connection to master node</summary>
@@ -4733,7 +4732,7 @@ public SnapshotGetDescriptor MasterTimeout(string master_timeout)
 	///</summary>
 	public partial class SnapshotGetRepositoryDescriptor
 	{
-		internal SnapshotGetRepositoryQueryString _QueryString = new SnapshotGetRepositoryQueryString(); 
+		internal SnapshotGetRepositoryRequestParameters _QueryString = new SnapshotGetRepositoryRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout for connection to master node</summary>
@@ -4762,7 +4761,7 @@ public SnapshotGetRepositoryDescriptor Local(bool local = true)
 	///</summary>
 	public partial class SnapshotRestoreDescriptor
 	{
-		internal SnapshotRestoreQueryString _QueryString = new SnapshotRestoreQueryString(); 
+		internal SnapshotRestoreRequestParameters _QueryString = new SnapshotRestoreRequestParameters(); 
 
 
 		///<summary>Explicit operation timeout for connection to master node</summary>
@@ -4791,7 +4790,7 @@ public SnapshotRestoreDescriptor WaitForCompletion(bool wait_for_completion = tr
 	///</summary>
 	public partial class SuggestDescriptor
 	{
-		internal SuggestQueryString _QueryString = new SuggestQueryString(); 
+		internal SuggestRequestParameters _QueryString = new SuggestRequestParameters(); 
 
 
 		///<summary>Whether specified concrete indices should be ignored when unavailable (missing or closed)</summary>
@@ -4852,7 +4851,7 @@ public SuggestDescriptor Source(string source)
 	///</summary>
 	public partial class TermvectorDescriptor
 	{
-		internal TermvectorQueryString _QueryString = new TermvectorQueryString(); 
+		internal TermvectorRequestParameters _QueryString = new TermvectorRequestParameters(); 
 
 
 		///<summary>Specifies if total term frequency and document frequency should be returned.</summary>
@@ -4948,7 +4947,7 @@ public TermvectorDescriptor Parent(string parent)
 	///</summary>
 	public partial class UpdateDescriptor<T,K>
 	{
-		internal UpdateQueryString _QueryString = new UpdateQueryString(); 
+		internal UpdateRequestParameters _QueryString = new UpdateRequestParameters(); 
 
 
 		///<summary>Explicit write consistency setting for the operation</summary>
diff --git a/src/Nest/Domain/DSL/IPathInfo.cs b/src/Nest/Domain/DSL/IPathInfo.cs
index 3a38928fa51..d961e84f103 100644
--- a/src/Nest/Domain/DSL/IPathInfo.cs
+++ b/src/Nest/Domain/DSL/IPathInfo.cs
@@ -2,7 +2,7 @@
 
 namespace Nest
 {
-	interface IPathInfo<K> where K : FluentQueryString<K>, new()
+	interface IPathInfo<K> where K : FluentRequestParameters<K>, new()
 	{
 		ElasticsearchPathInfo<K> ToPathInfo(IConnectionSettingsValues settings);
 	}
diff --git a/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs b/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs
index c22f47885bf..ff1bca821dc 100644
--- a/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs
+++ b/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs
@@ -2,7 +2,7 @@
 
 namespace Nest
 {
-	internal class ElasticsearchPathInfo<T> where T : FluentQueryString<T>, new()
+	internal class ElasticsearchPathInfo<T> where T : FluentRequestParameters<T>, new()
 	{
 		public PathInfoHttpMethod HttpMethod { get; set; }
 		public string Index { get; set; }
diff --git a/src/Nest/Domain/QueryStringParametersExtensions.Generated.cs b/src/Nest/Domain/RequestParametersExtensions.Generated.cs
similarity index 75%
rename from src/Nest/Domain/QueryStringParametersExtensions.Generated.cs
rename to src/Nest/Domain/RequestParametersExtensions.Generated.cs
index 9f5ea8cfa4a..1917eb40bcf 100644
--- a/src/Nest/Domain/QueryStringParametersExtensions.Generated.cs
+++ b/src/Nest/Domain/RequestParametersExtensions.Generated.cs
@@ -7,18 +7,18 @@
 using Elasticsearch.Net;
 using Nest.Resolvers;
 
-///This file contains all the typed querystring parameters that are generated of the client spec.
+///This file contains all the typed request parameters that are generated of the client spec.
 ///This file is automatically generated from https://github.com/elasticsearch/elasticsearch-rest-api-spec
 ///Generated of commit 
 
 namespace Nest
 {
-	public static class QueryStringPameterExtensions
+	public static class RequestPameterExtensions
 	{
 		
 		///<summary>A comma-separated list of fields to return in the response</summary>
-			internal static ExplainQueryString _Fields<T>(
-				this ExplainQueryString qs,
+			internal static ExplainRequestParameters _Fields<T>(
+				this ExplainRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fields)
 			where T : class
 		{
@@ -29,8 +29,8 @@ internal static ExplainQueryString _Fields<T>(
 		
 		
 		///<summary>A list of fields to exclude from the returned _source field</summary>
-			internal static ExplainQueryString _SourceExclude<T>(
-				this ExplainQueryString qs,
+			internal static ExplainRequestParameters _SourceExclude<T>(
+				this ExplainRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  _source_exclude)
 			where T : class
 		{
@@ -41,8 +41,8 @@ internal static ExplainQueryString _SourceExclude<T>(
 		
 		
 		///<summary>A list of fields to extract and return from the _source field</summary>
-			internal static ExplainQueryString _SourceInclude<T>(
-				this ExplainQueryString qs,
+			internal static ExplainRequestParameters _SourceInclude<T>(
+				this ExplainRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  _source_include)
 			where T : class
 		{
@@ -53,8 +53,8 @@ internal static ExplainQueryString _SourceInclude<T>(
 		
 		
 		///<summary>A comma-separated list of fields to return in the response</summary>
-			internal static GetQueryString _Fields<T>(
-				this GetQueryString qs,
+			internal static GetRequestParameters _Fields<T>(
+				this GetRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fields)
 			where T : class
 		{
@@ -65,8 +65,8 @@ internal static GetQueryString _Fields<T>(
 		
 		
 		///<summary>A list of fields to exclude from the returned _source field</summary>
-			internal static GetQueryString _SourceExclude<T>(
-				this GetQueryString qs,
+			internal static GetRequestParameters _SourceExclude<T>(
+				this GetRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  _source_exclude)
 			where T : class
 		{
@@ -77,8 +77,8 @@ internal static GetQueryString _SourceExclude<T>(
 		
 		
 		///<summary>A list of fields to extract and return from the _source field</summary>
-			internal static GetQueryString _SourceInclude<T>(
-				this GetQueryString qs,
+			internal static GetRequestParameters _SourceInclude<T>(
+				this GetRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  _source_include)
 			where T : class
 		{
@@ -89,8 +89,8 @@ internal static GetQueryString _SourceInclude<T>(
 		
 		
 		///<summary>A list of fields to exclude from the returned _source field</summary>
-			internal static SourceQueryString _SourceExclude<T>(
-				this SourceQueryString qs,
+			internal static SourceRequestParameters _SourceExclude<T>(
+				this SourceRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  _source_exclude)
 			where T : class
 		{
@@ -101,8 +101,8 @@ internal static SourceQueryString _SourceExclude<T>(
 		
 		
 		///<summary>A list of fields to extract and return from the _source field</summary>
-			internal static SourceQueryString _SourceInclude<T>(
-				this SourceQueryString qs,
+			internal static SourceRequestParameters _SourceInclude<T>(
+				this SourceRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  _source_include)
 			where T : class
 		{
@@ -113,8 +113,8 @@ internal static SourceQueryString _SourceInclude<T>(
 		
 		
 		///<summary>Use the analyzer configured for this field (instead of passing the analyzer name)</summary>
-			internal static AnalyzeQueryString _Field<T>(
-				this AnalyzeQueryString qs,
+			internal static AnalyzeRequestParameters _Field<T>(
+				this AnalyzeRequestParameters qs,
 				Expression<Func<T, object>> field)
 			where T : class
 		{
@@ -126,8 +126,8 @@ internal static AnalyzeQueryString _Field<T>(
 		
 		
 		///<summary>A comma-separated list of fields to clear when using the `field_data` parameter (default: all)</summary>
-			internal static ClearCacheQueryString _Fields<T>(
-				this ClearCacheQueryString qs,
+			internal static ClearCacheRequestParameters _Fields<T>(
+				this ClearCacheRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fields)
 			where T : class
 		{
@@ -138,8 +138,8 @@ internal static ClearCacheQueryString _Fields<T>(
 		
 		
 		///<summary>A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)</summary>
-			internal static IndicesStatsQueryString _CompletionFields<T>(
-				this IndicesStatsQueryString qs,
+			internal static IndicesStatsRequestParameters _CompletionFields<T>(
+				this IndicesStatsRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  completion_fields)
 			where T : class
 		{
@@ -150,8 +150,8 @@ internal static IndicesStatsQueryString _CompletionFields<T>(
 		
 		
 		///<summary>A comma-separated list of fields for `fielddata` index metric (supports wildcards)</summary>
-			internal static IndicesStatsQueryString _FielddataFields<T>(
-				this IndicesStatsQueryString qs,
+			internal static IndicesStatsRequestParameters _FielddataFields<T>(
+				this IndicesStatsRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fielddata_fields)
 			where T : class
 		{
@@ -162,8 +162,8 @@ internal static IndicesStatsQueryString _FielddataFields<T>(
 		
 		
 		///<summary>A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)</summary>
-			internal static IndicesStatsQueryString _Fields<T>(
-				this IndicesStatsQueryString qs,
+			internal static IndicesStatsRequestParameters _Fields<T>(
+				this IndicesStatsRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fields)
 			where T : class
 		{
@@ -174,8 +174,8 @@ internal static IndicesStatsQueryString _Fields<T>(
 		
 		
 		///<summary>A comma-separated list of fields to return in the response</summary>
-			internal static MultiGetQueryString _Fields<T>(
-				this MultiGetQueryString qs,
+			internal static MultiGetRequestParameters _Fields<T>(
+				this MultiGetRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fields)
 			where T : class
 		{
@@ -186,8 +186,8 @@ internal static MultiGetQueryString _Fields<T>(
 		
 		
 		///<summary>A list of fields to exclude from the returned _source field</summary>
-			internal static MultiGetQueryString _SourceExclude<T>(
-				this MultiGetQueryString qs,
+			internal static MultiGetRequestParameters _SourceExclude<T>(
+				this MultiGetRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  _source_exclude)
 			where T : class
 		{
@@ -198,8 +198,8 @@ internal static MultiGetQueryString _SourceExclude<T>(
 		
 		
 		///<summary>A list of fields to extract and return from the _source field</summary>
-			internal static MultiGetQueryString _SourceInclude<T>(
-				this MultiGetQueryString qs,
+			internal static MultiGetRequestParameters _SourceInclude<T>(
+				this MultiGetRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  _source_include)
 			where T : class
 		{
@@ -210,8 +210,8 @@ internal static MultiGetQueryString _SourceInclude<T>(
 		
 		
 		///<summary>Specific fields to perform the query against</summary>
-			internal static MoreLikeThisQueryString _MltFields<T>(
-				this MoreLikeThisQueryString qs,
+			internal static MoreLikeThisRequestParameters _MltFields<T>(
+				this MoreLikeThisRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  mlt_fields)
 			where T : class
 		{
@@ -222,8 +222,8 @@ internal static MoreLikeThisQueryString _MltFields<T>(
 		
 		
 		///<summary>A comma-separated list of fields to return. Applies to all returned documents unless otherwise specified in body &quot;params&quot; or &quot;docs&quot;.</summary>
-			internal static MtermvectorsQueryString _Fields<T>(
-				this MtermvectorsQueryString qs,
+			internal static MtermvectorsRequestParameters _Fields<T>(
+				this MtermvectorsRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fields)
 			where T : class
 		{
@@ -234,8 +234,8 @@ internal static MtermvectorsQueryString _Fields<T>(
 		
 		
 		///<summary>A comma-separated list of fields for `fielddata` and `suggest` index metric (supports wildcards)</summary>
-			internal static NodesStatsQueryString _CompletionFields<T>(
-				this NodesStatsQueryString qs,
+			internal static NodesStatsRequestParameters _CompletionFields<T>(
+				this NodesStatsRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  completion_fields)
 			where T : class
 		{
@@ -246,8 +246,8 @@ internal static NodesStatsQueryString _CompletionFields<T>(
 		
 		
 		///<summary>A comma-separated list of fields for `fielddata` index metric (supports wildcards)</summary>
-			internal static NodesStatsQueryString _FielddataFields<T>(
-				this NodesStatsQueryString qs,
+			internal static NodesStatsRequestParameters _FielddataFields<T>(
+				this NodesStatsRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fielddata_fields)
 			where T : class
 		{
@@ -258,8 +258,8 @@ internal static NodesStatsQueryString _FielddataFields<T>(
 		
 		
 		///<summary>A comma-separated list of fields for `fielddata` and `completion` index metric (supports wildcards)</summary>
-			internal static NodesStatsQueryString _Fields<T>(
-				this NodesStatsQueryString qs,
+			internal static NodesStatsRequestParameters _Fields<T>(
+				this NodesStatsRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fields)
 			where T : class
 		{
@@ -270,8 +270,8 @@ internal static NodesStatsQueryString _Fields<T>(
 		
 		
 		///<summary>Specify which field to use for suggestions</summary>
-			internal static SearchQueryString _SuggestField<T>(
-				this SearchQueryString qs,
+			internal static SearchRequestParameters _SuggestField<T>(
+				this SearchRequestParameters qs,
 				Expression<Func<T, object>> suggest_field)
 			where T : class
 		{
@@ -283,8 +283,8 @@ internal static SearchQueryString _SuggestField<T>(
 		
 		
 		///<summary>A comma-separated list of fields to return.</summary>
-			internal static TermvectorQueryString _Fields<T>(
-				this TermvectorQueryString qs,
+			internal static TermvectorRequestParameters _Fields<T>(
+				this TermvectorRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fields)
 			where T : class
 		{
@@ -295,8 +295,8 @@ internal static TermvectorQueryString _Fields<T>(
 		
 		
 		///<summary>A comma-separated list of fields to return in the response</summary>
-			internal static UpdateQueryString _Fields<T>(
-				this UpdateQueryString qs,
+			internal static UpdateRequestParameters _Fields<T>(
+				this UpdateRequestParameters qs,
 				IEnumerable<Expression<Func<T, object>>>  fields)
 			where T : class
 		{
diff --git a/src/Nest/ElasticClient-Aliases.cs b/src/Nest/ElasticClient-Aliases.cs
index fd5cacad67c..aaecc207622 100644
--- a/src/Nest/ElasticClient-Aliases.cs
+++ b/src/Nest/ElasticClient-Aliases.cs
@@ -15,7 +15,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IIndicesOperationResponse Alias(Func<AliasDescriptor, AliasDescriptor> aliasSelector)
 		{
-			return this.Dispatch<AliasDescriptor, AliasQueryString, IndicesOperationResponse>(
+			return this.Dispatch<AliasDescriptor, AliasRequestParameters, IndicesOperationResponse>(
 				aliasSelector,
 				(p, d) => this.RawDispatch.IndicesUpdateAliasesDispatch<IndicesOperationResponse>(p, d)
 			);
@@ -24,7 +24,7 @@ public IIndicesOperationResponse Alias(Func<AliasDescriptor, AliasDescriptor> al
 		/// <inheritdoc />
 		public Task<IIndicesOperationResponse> AliasAsync(Func<AliasDescriptor, AliasDescriptor> aliasSelector)
 		{
-			return this.DispatchAsync<AliasDescriptor, AliasQueryString, IndicesOperationResponse, IIndicesOperationResponse>(
+			return this.DispatchAsync<AliasDescriptor, AliasRequestParameters, IndicesOperationResponse, IIndicesOperationResponse>(
 				aliasSelector,
 				(p, d) => this.RawDispatch.IndicesUpdateAliasesDispatchAsync<IndicesOperationResponse>(p, d)
 			);
@@ -33,7 +33,7 @@ public Task<IIndicesOperationResponse> AliasAsync(Func<AliasDescriptor, AliasDes
 		/// <inheritdoc />
 		public IGetAliasesResponse GetAliases(Func<GetAliasesDescriptor, GetAliasesDescriptor> getAliasesDescriptor)
 		{
-			return this.Dispatch<GetAliasesDescriptor, GetAliasesQueryString, GetAliasesResponse>(
+			return this.Dispatch<GetAliasesDescriptor, GetAliasesRequestParameters, GetAliasesResponse>(
 				getAliasesDescriptor,
 				(p, d) => this.RawDispatch.IndicesGetAliasDispatch<GetAliasesResponse>(
 					p,
@@ -45,7 +45,7 @@ public IGetAliasesResponse GetAliases(Func<GetAliasesDescriptor, GetAliasesDescr
 		/// <inheritdoc />
 		public Task<IGetAliasesResponse> GetAliasesAsync(Func<GetAliasesDescriptor, GetAliasesDescriptor> getAliasesDescriptor)
 		{
-			return this.DispatchAsync<GetAliasesDescriptor, GetAliasesQueryString, GetAliasesResponse, IGetAliasesResponse>(
+			return this.DispatchAsync<GetAliasesDescriptor, GetAliasesRequestParameters, GetAliasesResponse, IGetAliasesResponse>(
 				getAliasesDescriptor,
 				(p, d) => this.RawDispatch.IndicesGetAliasDispatchAsync<GetAliasesResponse>(
 					p,
diff --git a/src/Nest/ElasticClient-Analyze.cs b/src/Nest/ElasticClient-Analyze.cs
index e1fca44d76b..f4981234628 100644
--- a/src/Nest/ElasticClient-Analyze.cs
+++ b/src/Nest/ElasticClient-Analyze.cs
@@ -9,7 +9,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IAnalyzeResponse Analyze(Func<AnalyzeDescriptor, AnalyzeDescriptor> analyzeSelector)
 		{
-			return this.Dispatch<AnalyzeDescriptor, AnalyzeQueryString, AnalyzeResponse>(
+			return this.Dispatch<AnalyzeDescriptor, AnalyzeRequestParameters, AnalyzeResponse>(
 				analyzeSelector,
 				(p, d) => this.RawDispatch.IndicesAnalyzeDispatch<AnalyzeResponse>(p, d)
 			);
@@ -18,7 +18,7 @@ public IAnalyzeResponse Analyze(Func<AnalyzeDescriptor, AnalyzeDescriptor> analy
 		/// <inheritdoc />
 		public Task<IAnalyzeResponse> AnalyzeAsync(Func<AnalyzeDescriptor, AnalyzeDescriptor> analyzeSelector)
 		{
-			return this.DispatchAsync<AnalyzeDescriptor, AnalyzeQueryString, AnalyzeResponse, IAnalyzeResponse>(
+			return this.DispatchAsync<AnalyzeDescriptor, AnalyzeRequestParameters, AnalyzeResponse, IAnalyzeResponse>(
 				analyzeSelector,
 				(p, d) => this.RawDispatch.IndicesAnalyzeDispatchAsync<AnalyzeResponse>(p, d)
 			);
diff --git a/src/Nest/ElasticClient-Bulk.cs b/src/Nest/ElasticClient-Bulk.cs
index 3a97025f60a..3bf73220edd 100644
--- a/src/Nest/ElasticClient-Bulk.cs
+++ b/src/Nest/ElasticClient-Bulk.cs
@@ -12,7 +12,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IBulkResponse Bulk(Func<BulkDescriptor, BulkDescriptor> bulkSelector)
 		{
-			return this.Dispatch<BulkDescriptor, BulkQueryString, BulkResponse>(
+			return this.Dispatch<BulkDescriptor, BulkRequestParameters, BulkResponse>(
 				bulkSelector,
 				(p, d) =>
 				{
@@ -25,7 +25,7 @@ public IBulkResponse Bulk(Func<BulkDescriptor, BulkDescriptor> bulkSelector)
 		/// <inheritdoc />
 		public Task<IBulkResponse> BulkAsync(Func<BulkDescriptor, BulkDescriptor> bulkSelector)
 		{
-			return this.DispatchAsync<BulkDescriptor, BulkQueryString, BulkResponse, IBulkResponse>(
+			return this.DispatchAsync<BulkDescriptor, BulkRequestParameters, BulkResponse, IBulkResponse>(
 				bulkSelector,
 				(p, d) =>
 				{
diff --git a/src/Nest/ElasticClient-ClearCache.cs b/src/Nest/ElasticClient-ClearCache.cs
index d61ca69d377..61e717c3cc2 100644
--- a/src/Nest/ElasticClient-ClearCache.cs
+++ b/src/Nest/ElasticClient-ClearCache.cs
@@ -12,7 +12,7 @@ public partial class ElasticClient
 		public IShardsOperationResponse ClearCache(Func<ClearCacheDescriptor, ClearCacheDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.Dispatch<ClearCacheDescriptor, ClearCacheQueryString, ShardsOperationResponse>(
+			return this.Dispatch<ClearCacheDescriptor, ClearCacheRequestParameters, ShardsOperationResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesClearCacheDispatch<ShardsOperationResponse>(p)
 			);
@@ -22,7 +22,7 @@ public IShardsOperationResponse ClearCache(Func<ClearCacheDescriptor, ClearCache
 		public Task<IShardsOperationResponse> ClearCacheAsync(Func<ClearCacheDescriptor, ClearCacheDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.DispatchAsync<ClearCacheDescriptor, ClearCacheQueryString, ShardsOperationResponse, IShardsOperationResponse>(
+			return this.DispatchAsync<ClearCacheDescriptor, ClearCacheRequestParameters, ShardsOperationResponse, IShardsOperationResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesClearCacheDispatchAsync<ShardsOperationResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-ClusterHealth.cs b/src/Nest/ElasticClient-ClusterHealth.cs
index f164fdf74a3..bd6f73c853b 100644
--- a/src/Nest/ElasticClient-ClusterHealth.cs
+++ b/src/Nest/ElasticClient-ClusterHealth.cs
@@ -13,7 +13,7 @@ public IHealthResponse ClusterHealth(
 			Func<ClusterHealthDescriptor, ClusterHealthDescriptor> clusterHealthSelector = null)
 		{
 			clusterHealthSelector = clusterHealthSelector ?? (s => s);
-			return this.Dispatch<ClusterHealthDescriptor, ClusterHealthQueryString, HealthResponse>(
+			return this.Dispatch<ClusterHealthDescriptor, ClusterHealthRequestParameters, HealthResponse>(
 				clusterHealthSelector,
 				(p, d) => this.RawDispatch.ClusterHealthDispatch<HealthResponse>(p)
 			);
@@ -24,7 +24,7 @@ public Task<IHealthResponse> ClusterHealthAsync(
 			Func<ClusterHealthDescriptor, ClusterHealthDescriptor> clusterHealthSelector = null)
 		{
 			clusterHealthSelector = clusterHealthSelector ?? (s => s);
-			return this.DispatchAsync<ClusterHealthDescriptor, ClusterHealthQueryString, HealthResponse, IHealthResponse>(
+			return this.DispatchAsync<ClusterHealthDescriptor, ClusterHealthRequestParameters, HealthResponse, IHealthResponse>(
 				clusterHealthSelector,
 				(p, d) => this.RawDispatch.ClusterHealthDispatchAsync<HealthResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-Count.cs b/src/Nest/ElasticClient-Count.cs
index 4c68e82599a..09a446efec1 100644
--- a/src/Nest/ElasticClient-Count.cs
+++ b/src/Nest/ElasticClient-Count.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		public ICountResponse Count<T>(Func<CountDescriptor<T>, CountDescriptor<T>> countSelector = null) where T : class
 		{
 			countSelector = countSelector ?? (s => s);
-			return this.Dispatch<CountDescriptor<T>, CountQueryString, CountResponse>(
+			return this.Dispatch<CountDescriptor<T>, CountRequestParameters, CountResponse>(
 				countSelector,
 				(p, d) => this.RawDispatch.CountDispatch<CountResponse>(p, d)
 			);
@@ -22,7 +22,7 @@ public Task<ICountResponse> CountAsync<T>(Func<CountDescriptor<T>, CountDescript
 			where T : class
 		{
 			countSelector = countSelector ?? (s => s);
-			return this.DispatchAsync<CountDescriptor<T>, CountQueryString, CountResponse, ICountResponse>(
+			return this.DispatchAsync<CountDescriptor<T>, CountRequestParameters, CountResponse, ICountResponse>(
 				countSelector,
 				(p, d) => this.RawDispatch.CountDispatchAsync<CountResponse>(p, d)
 			);
diff --git a/src/Nest/ElasticClient-CreateIndex.cs b/src/Nest/ElasticClient-CreateIndex.cs
index a8b860d849b..8c6d1706e43 100644
--- a/src/Nest/ElasticClient-CreateIndex.cs
+++ b/src/Nest/ElasticClient-CreateIndex.cs
@@ -16,7 +16,7 @@ public IIndicesOperationResponse CreateIndex(string index,
 			createIndexSelector = createIndexSelector ?? (c => c);
 			var descriptor = createIndexSelector(new CreateIndexDescriptor(_connectionSettings));
 			descriptor._Index = index;
-			return this.Dispatch<CreateIndexDescriptor, CreateIndexQueryString, IndicesOperationResponse>(
+			return this.Dispatch<CreateIndexDescriptor, CreateIndexRequestParameters, IndicesOperationResponse>(
 				descriptor,
 				(p, d) => this.RawDispatch.IndicesCreateDispatch<IndicesOperationResponse>(p, d._IndexSettings)
 			);
@@ -31,7 +31,7 @@ public Task<IIndicesOperationResponse> CreateIndexAsync(string index,
 			var descriptor = createIndexSelector(new CreateIndexDescriptor(_connectionSettings));
 			descriptor._Index = index;
 			return this.DispatchAsync
-				<CreateIndexDescriptor, CreateIndexQueryString, IndicesOperationResponse, IIndicesOperationResponse>(
+				<CreateIndexDescriptor, CreateIndexRequestParameters, IndicesOperationResponse, IIndicesOperationResponse>(
 					descriptor,
 					(p, d) => this.RawDispatch.IndicesCreateDispatchAsync<IndicesOperationResponse>(p, d._IndexSettings)
 				);
diff --git a/src/Nest/ElasticClient-Delete.cs b/src/Nest/ElasticClient-Delete.cs
index 983f631df1a..ae40e2ed99a 100644
--- a/src/Nest/ElasticClient-Delete.cs
+++ b/src/Nest/ElasticClient-Delete.cs
@@ -10,7 +10,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IDeleteResponse Delete<T>(Func<DeleteDescriptor<T>, DeleteDescriptor<T>> deleteSelector) where T : class
 		{
-			return this.Dispatch<DeleteDescriptor<T>, DeleteQueryString, DeleteResponse>(
+			return this.Dispatch<DeleteDescriptor<T>, DeleteRequestParameters, DeleteResponse>(
 				deleteSelector,
 				(p, d) => this.RawDispatch.DeleteDispatch<DeleteResponse>(p)
 			);
@@ -20,7 +20,7 @@ public IDeleteResponse Delete<T>(Func<DeleteDescriptor<T>, DeleteDescriptor<T>>
 		public Task<IDeleteResponse> DeleteAsync<T>(Func<DeleteDescriptor<T>, DeleteDescriptor<T>> deleteSelector)
 			where T : class
 		{
-			return this.DispatchAsync<DeleteDescriptor<T>, DeleteQueryString, DeleteResponse, IDeleteResponse>(
+			return this.DispatchAsync<DeleteDescriptor<T>, DeleteRequestParameters, DeleteResponse, IDeleteResponse>(
 				deleteSelector,
 				(p, d) => this.RawDispatch.DeleteDispatchAsync<DeleteResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-DeleteByQuery.cs b/src/Nest/ElasticClient-DeleteByQuery.cs
index 5e1a7d46742..56fd960a1b3 100644
--- a/src/Nest/ElasticClient-DeleteByQuery.cs
+++ b/src/Nest/ElasticClient-DeleteByQuery.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		public IDeleteResponse DeleteByQuery<T>(
 			Func<DeleteByQueryDescriptor<T>, DeleteByQueryDescriptor<T>> deleteByQuerySelector) where T : class
 		{
-			return this.Dispatch<DeleteByQueryDescriptor<T>, DeleteByQueryQueryString, DeleteResponse>(
+			return this.Dispatch<DeleteByQueryDescriptor<T>, DeleteByQueryRequestParameters, DeleteResponse>(
 				deleteByQuerySelector,
 				(p, d) => this.RawDispatch.DeleteByQueryDispatch<DeleteResponse>(p, d)
 			);
@@ -21,7 +21,7 @@ public IDeleteResponse DeleteByQuery<T>(
 		public Task<IDeleteResponse> DeleteByQueryAsync<T>(
 			Func<DeleteByQueryDescriptor<T>, DeleteByQueryDescriptor<T>> deleteByQuerySelector) where T : class
 		{
-			return this.DispatchAsync<DeleteByQueryDescriptor<T>, DeleteByQueryQueryString, DeleteResponse, IDeleteResponse>(
+			return this.DispatchAsync<DeleteByQueryDescriptor<T>, DeleteByQueryRequestParameters, DeleteResponse, IDeleteResponse>(
 				deleteByQuerySelector,
 				(p, d) => this.RawDispatch.DeleteByQueryDispatchAsync<DeleteResponse>(p, d)
 			);
diff --git a/src/Nest/ElasticClient-Flush.cs b/src/Nest/ElasticClient-Flush.cs
index 33bf110c4f5..cf5c81c4437 100644
--- a/src/Nest/ElasticClient-Flush.cs
+++ b/src/Nest/ElasticClient-Flush.cs
@@ -10,7 +10,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IShardsOperationResponse Flush(Func<FlushDescriptor, FlushDescriptor> selector)
 		{
-			return this.Dispatch<FlushDescriptor, FlushQueryString, ShardsOperationResponse>(
+			return this.Dispatch<FlushDescriptor, FlushRequestParameters, ShardsOperationResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesFlushDispatch<ShardsOperationResponse>(p)
 			);
@@ -19,7 +19,7 @@ public IShardsOperationResponse Flush(Func<FlushDescriptor, FlushDescriptor> sel
 		/// <inheritdoc />
 		public Task<IShardsOperationResponse> FlushAsync(Func<FlushDescriptor, FlushDescriptor> selector)
 		{
-			return this.DispatchAsync<FlushDescriptor, FlushQueryString, ShardsOperationResponse, IShardsOperationResponse>(
+			return this.DispatchAsync<FlushDescriptor, FlushRequestParameters, ShardsOperationResponse, IShardsOperationResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesFlushDispatchAsync<ShardsOperationResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-GatewaySnapshot.cs b/src/Nest/ElasticClient-GatewaySnapshot.cs
index 3d3e9cdece8..65b62815cc2 100644
--- a/src/Nest/ElasticClient-GatewaySnapshot.cs
+++ b/src/Nest/ElasticClient-GatewaySnapshot.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		public IShardsOperationResponse GatewaySnapshot(Func<SnapshotDescriptor, SnapshotDescriptor> snapshotSelector = null)
 		{
 			snapshotSelector = snapshotSelector ?? (s => s);
-			return this.Dispatch<SnapshotDescriptor, SnapshotQueryString, ShardsOperationResponse>(
+			return this.Dispatch<SnapshotDescriptor, SnapshotRequestParameters, ShardsOperationResponse>(
 				snapshotSelector,
 				(p, d) => this.RawDispatch.IndicesSnapshotIndexDispatch<ShardsOperationResponse>(p)
 			);
@@ -22,7 +22,7 @@ public Task<IShardsOperationResponse> GatewaySnapshotAsync(
 			Func<SnapshotDescriptor, SnapshotDescriptor> snapshotSelector = null)
 		{
 			snapshotSelector = snapshotSelector ?? (s => s);
-			return this.DispatchAsync<SnapshotDescriptor, SnapshotQueryString, ShardsOperationResponse, IShardsOperationResponse>(
+			return this.DispatchAsync<SnapshotDescriptor, SnapshotRequestParameters, ShardsOperationResponse, IShardsOperationResponse>(
 				snapshotSelector,
 				(p, d) => this.RawDispatch.IndicesSnapshotIndexDispatchAsync<ShardsOperationResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-Get.cs b/src/Nest/ElasticClient-Get.cs
index 631a0c67273..e5523fc2f97 100644
--- a/src/Nest/ElasticClient-Get.cs
+++ b/src/Nest/ElasticClient-Get.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IGetResponse<T> Get<T>(Func<GetDescriptor<T>, GetDescriptor<T>> getSelector) where T : class
 		{
-			return this.Dispatch<GetDescriptor<T>, GetQueryString, GetResponse<T>>(
+			return this.Dispatch<GetDescriptor<T>, GetRequestParameters, GetResponse<T>>(
 				getSelector,
 				(p, d) => this.RawDispatch.GetDispatch<GetResponse<T>>(p)
 			);
@@ -20,7 +20,7 @@ public IGetResponse<T> Get<T>(Func<GetDescriptor<T>, GetDescriptor<T>> getSelect
 		/// <inheritdoc />
 		public Task<IGetResponse<T>> GetAsync<T>(Func<GetDescriptor<T>, GetDescriptor<T>> getSelector) where T : class
 		{
-			return this.DispatchAsync<GetDescriptor<T>, GetQueryString, GetResponse<T>, IGetResponse<T>>(
+			return this.DispatchAsync<GetDescriptor<T>, GetRequestParameters, GetResponse<T>, IGetResponse<T>>(
 				getSelector,
 				(p, d) => this.RawDispatch.GetDispatchAsync<GetResponse<T>>(p)
 			);
diff --git a/src/Nest/ElasticClient-Index.cs b/src/Nest/ElasticClient-Index.cs
index a0080bf5865..d53674b83ac 100644
--- a/src/Nest/ElasticClient-Index.cs
+++ b/src/Nest/ElasticClient-Index.cs
@@ -14,7 +14,7 @@ public IIndexResponse Index<T>(T @object, Func<IndexDescriptor<T>, IndexDescript
 			@object.ThrowIfNull("object");
 			indexSelector = indexSelector ?? (s => s);
 			var descriptor = indexSelector(new IndexDescriptor<T>().Object(@object));
-			return this.Dispatch<IndexDescriptor<T>, IndexQueryString, IndexResponse>(
+			return this.Dispatch<IndexDescriptor<T>, IndexRequestParameters, IndexResponse>(
 				descriptor,
 				(p, d) => this.RawDispatch.IndexDispatch<IndexResponse>(p, @object));
 		}
@@ -26,7 +26,7 @@ public Task<IIndexResponse> IndexAsync<T>(T @object, Func<IndexDescriptor<T>, In
 			@object.ThrowIfNull("object");
 			indexSelector = indexSelector ?? (s => s);
 			var descriptor = indexSelector(new IndexDescriptor<T>().Object(@object));
-			return this.DispatchAsync<IndexDescriptor<T>, IndexQueryString, IndexResponse, IIndexResponse>(
+			return this.DispatchAsync<IndexDescriptor<T>, IndexRequestParameters, IndexResponse, IIndexResponse>(
 				descriptor,
 				(p, d) => this.RawDispatch.IndexDispatchAsync<IndexResponse>(p, @object));
 		}
diff --git a/src/Nest/ElasticClient-IndexExists.cs b/src/Nest/ElasticClient-IndexExists.cs
index 14e6e218f0f..31e1aeed1d2 100644
--- a/src/Nest/ElasticClient-IndexExists.cs
+++ b/src/Nest/ElasticClient-IndexExists.cs
@@ -12,7 +12,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IIndexExistsResponse IndexExists(Func<IndexExistsDescriptor, IndexExistsDescriptor> selector)
 		{
-			return this.Dispatch<IndexExistsDescriptor, IndexExistsQueryString, IndexExistsResponse>(
+			return this.Dispatch<IndexExistsDescriptor, IndexExistsRequestParameters, IndexExistsResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesExistsDispatch<IndexExistsResponse>(
 					p,
@@ -24,7 +24,7 @@ public IIndexExistsResponse IndexExists(Func<IndexExistsDescriptor, IndexExistsD
 		/// <inheritdoc />
 		public Task<IIndexExistsResponse> IndexExistsAsync(Func<IndexExistsDescriptor, IndexExistsDescriptor> selector)
 		{
-			return this.DispatchAsync<IndexExistsDescriptor, IndexExistsQueryString, IndexExistsResponse, IIndexExistsResponse>(
+			return this.DispatchAsync<IndexExistsDescriptor, IndexExistsRequestParameters, IndexExistsResponse, IIndexExistsResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesExistsDispatchAsync<IndexExistsResponse>(
 					p,
diff --git a/src/Nest/ElasticClient-MappingDelete.cs b/src/Nest/ElasticClient-MappingDelete.cs
index ddf4fe4feda..f82737c108a 100644
--- a/src/Nest/ElasticClient-MappingDelete.cs
+++ b/src/Nest/ElasticClient-MappingDelete.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IIndicesResponse DeleteMapping(Func<DeleteMappingDescriptor, DeleteMappingDescriptor> selector)
 		{
-			return this.Dispatch<DeleteMappingDescriptor, DeleteMappingQueryString, IndicesResponse>(
+			return this.Dispatch<DeleteMappingDescriptor, DeleteMappingRequestParameters, IndicesResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesDeleteMappingDispatch<IndicesResponse>(p)
 			);
@@ -20,7 +20,7 @@ public IIndicesResponse DeleteMapping(Func<DeleteMappingDescriptor, DeleteMappin
 		/// <inheritdoc />
 		public Task<IIndicesResponse> DeleteMappingAsync(Func<DeleteMappingDescriptor, DeleteMappingDescriptor> selector)
 		{
-			return this.DispatchAsync<DeleteMappingDescriptor, DeleteMappingQueryString, IndicesResponse, IIndicesResponse>(
+			return this.DispatchAsync<DeleteMappingDescriptor, DeleteMappingRequestParameters, IndicesResponse, IIndicesResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesDeleteMappingDispatchAsync<IndicesResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-MappingGet.cs b/src/Nest/ElasticClient-MappingGet.cs
index 93d839945b2..ecd2a8c2018 100644
--- a/src/Nest/ElasticClient-MappingGet.cs
+++ b/src/Nest/ElasticClient-MappingGet.cs
@@ -14,7 +14,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IGetMappingResponse GetMapping(Func<GetMappingDescriptor, GetMappingDescriptor> selector)
 		{
-			return this.Dispatch<GetMappingDescriptor, GetMappingQueryString, GetMappingResponse>(
+			return this.Dispatch<GetMappingDescriptor, GetMappingRequestParameters, GetMappingResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesGetMappingDispatch<GetMappingResponse>(
 					p,
@@ -26,7 +26,7 @@ public IGetMappingResponse GetMapping(Func<GetMappingDescriptor, GetMappingDescr
 		/// <inheritdoc />
 		public Task<IGetMappingResponse> GetMappingAsync(Func<GetMappingDescriptor, GetMappingDescriptor> selector)
 		{
-			return this.DispatchAsync<GetMappingDescriptor, GetMappingQueryString, GetMappingResponse, IGetMappingResponse>(
+			return this.DispatchAsync<GetMappingDescriptor, GetMappingRequestParameters, GetMappingResponse, IGetMappingResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesGetMappingDispatchAsync<GetMappingResponse>(
 					p,
diff --git a/src/Nest/ElasticClient-MappingIndex.cs b/src/Nest/ElasticClient-MappingIndex.cs
index 775a922d45d..f6ec1025993 100644
--- a/src/Nest/ElasticClient-MappingIndex.cs
+++ b/src/Nest/ElasticClient-MappingIndex.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IIndexSettingsResponse GetIndexSettings(Func<GetIndexSettingsDescriptor, GetIndexSettingsDescriptor> selector)
 		{
-			return this.Dispatch<GetIndexSettingsDescriptor, GetIndexSettingsQueryString, IndexSettingsResponse>(
+			return this.Dispatch<GetIndexSettingsDescriptor, GetIndexSettingsRequestParameters, IndexSettingsResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesGetSettingsDispatch<IndexSettingsResponse>(p)
 			);
@@ -22,7 +22,7 @@ public Task<IIndexSettingsResponse> GetIndexSettingsAsync(
 			Func<GetIndexSettingsDescriptor, GetIndexSettingsDescriptor> selector)
 		{
 			return this.DispatchAsync
-				<GetIndexSettingsDescriptor, GetIndexSettingsQueryString, IndexSettingsResponse, IIndexSettingsResponse>(
+				<GetIndexSettingsDescriptor, GetIndexSettingsRequestParameters, IndexSettingsResponse, IIndexSettingsResponse>(
 					selector,
 					(p, d) => this.RawDispatch.IndicesGetSettingsDispatchAsync<IndexSettingsResponse>(p)
 				);
@@ -31,7 +31,7 @@ public Task<IIndexSettingsResponse> GetIndexSettingsAsync(
 		/// <inheritdoc />
 		public IIndicesResponse DeleteIndex(Func<DeleteIndexDescriptor, DeleteIndexDescriptor> selector)
 		{
-			return this.Dispatch<DeleteIndexDescriptor, DeleteIndexQueryString, IndicesResponse>(
+			return this.Dispatch<DeleteIndexDescriptor, DeleteIndexRequestParameters, IndicesResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesDeleteDispatch<IndicesResponse>(p)
 			);
@@ -40,7 +40,7 @@ public IIndicesResponse DeleteIndex(Func<DeleteIndexDescriptor, DeleteIndexDescr
 		/// <inheritdoc />
 		public Task<IIndicesResponse> DeleteIndexAsync(Func<DeleteIndexDescriptor, DeleteIndexDescriptor> selector)
 		{
-			return this.DispatchAsync<DeleteIndexDescriptor, DeleteIndexQueryString, IndicesResponse, IIndicesResponse>(
+			return this.DispatchAsync<DeleteIndexDescriptor, DeleteIndexRequestParameters, IndicesResponse, IIndicesResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesDeleteDispatchAsync<IndicesResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-MappingType.cs b/src/Nest/ElasticClient-MappingType.cs
index 8cba893ea1e..89217d58108 100644
--- a/src/Nest/ElasticClient-MappingType.cs
+++ b/src/Nest/ElasticClient-MappingType.cs
@@ -13,7 +13,7 @@ public IIndicesResponse Map<T>(Func<PutMappingDescriptor<T>, PutMappingDescripto
 		{
 			mappingSelector.ThrowIfNull("mappingSelector");
 			var descriptor = mappingSelector(new PutMappingDescriptor<T>(_connectionSettings));
-			return this.Dispatch<PutMappingDescriptor<T>, PutMappingQueryString, IndicesResponse>(
+			return this.Dispatch<PutMappingDescriptor<T>, PutMappingRequestParameters, IndicesResponse>(
 				descriptor,
 				(p, d) =>
 				{
@@ -32,7 +32,7 @@ public Task<IIndicesResponse> MapAsync<T>(Func<PutMappingDescriptor<T>, PutMappi
 		{
 			mappingSelector.ThrowIfNull("mappingSelector");
 			var descriptor = mappingSelector(new PutMappingDescriptor<T>(_connectionSettings));
-			return this.DispatchAsync<PutMappingDescriptor<T>, PutMappingQueryString, IndicesResponse, IIndicesResponse>(
+			return this.DispatchAsync<PutMappingDescriptor<T>, PutMappingRequestParameters, IndicesResponse, IIndicesResponse>(
 				descriptor,
 				(p, d) =>
 				{
diff --git a/src/Nest/ElasticClient-MoreLikeThis.cs b/src/Nest/ElasticClient-MoreLikeThis.cs
index 8cc2c3fb6d1..dfeec7d5908 100644
--- a/src/Nest/ElasticClient-MoreLikeThis.cs
+++ b/src/Nest/ElasticClient-MoreLikeThis.cs
@@ -11,11 +11,11 @@ public partial class ElasticClient
 		public IQueryResponse<T> MoreLikeThis<T>(Func<MoreLikeThisDescriptor<T>, MoreLikeThisDescriptor<T>> mltSelector)
 			where T : class
 		{
-			return this.Dispatch<MoreLikeThisDescriptor<T>, MoreLikeThisQueryString, QueryResponse<T>>(
+			return this.Dispatch<MoreLikeThisDescriptor<T>, MoreLikeThisRequestParameters, QueryResponse<T>>(
 				mltSelector,
 				(p, d) =>
 				{
-					CopySearchQueryString(d);
+					CopySearchRequestParameters(d);
 					return this.RawDispatch.MltDispatch<QueryResponse<T>>(p, d._Search);
 				}
 			);
@@ -25,17 +25,17 @@ public IQueryResponse<T> MoreLikeThis<T>(Func<MoreLikeThisDescriptor<T>, MoreLik
 		public Task<IQueryResponse<T>> MoreLikeThisAsync<T>(
 			Func<MoreLikeThisDescriptor<T>, MoreLikeThisDescriptor<T>> mltSelector) where T : class
 		{
-			return this.DispatchAsync<MoreLikeThisDescriptor<T>, MoreLikeThisQueryString, QueryResponse<T>, IQueryResponse<T>>(
+			return this.DispatchAsync<MoreLikeThisDescriptor<T>, MoreLikeThisRequestParameters, QueryResponse<T>, IQueryResponse<T>>(
 				mltSelector,
 				(p, d) =>
 				{
-					CopySearchQueryString(d);
+					CopySearchRequestParameters(d);
 					return this.RawDispatch.MltDispatchAsync<QueryResponse<T>>(p, d._Search);
 				}
 			);
 		}
 
-		private static void CopySearchQueryString<T>(MoreLikeThisDescriptor<T> d) where T : class
+		private static void CopySearchRequestParameters<T>(MoreLikeThisDescriptor<T> d) where T : class
 		{
 			if (d._Search == null) return;
 			var searchQs = d._Search._QueryString._QueryStringDictionary;
diff --git a/src/Nest/ElasticClient-MultiGet.cs b/src/Nest/ElasticClient-MultiGet.cs
index 5b614d80218..18e313e7a9c 100644
--- a/src/Nest/ElasticClient-MultiGet.cs
+++ b/src/Nest/ElasticClient-MultiGet.cs
@@ -16,7 +16,7 @@ public IMultiGetResponse MultiGet(Func<MultiGetDescriptor, MultiGetDescriptor> m
 			multiGetSelector.ThrowIfNull("multiGetSelector");
 			var descriptor = multiGetSelector(new MultiGetDescriptor(_connectionSettings));
 			var converter = CreateCovariantMultiGetConverter(descriptor);
-			return this.Dispatch<MultiGetDescriptor, MultiGetQueryString, MultiGetResponse>(
+			return this.Dispatch<MultiGetDescriptor, MultiGetRequestParameters, MultiGetResponse>(
 				descriptor,
 				(p, d) => this.RawDispatch.MgetDispatch<MultiGetResponse>(p, d, converter)
 			);
@@ -28,7 +28,7 @@ public Task<IMultiGetResponse> MultiGetAsync(Func<MultiGetDescriptor, MultiGetDe
 			multiGetSelector.ThrowIfNull("multiGetSelector");
 			var descriptor = multiGetSelector(new MultiGetDescriptor(_connectionSettings));
 			var converter = CreateCovariantMultiGetConverter(descriptor);
-			return this.DispatchAsync<MultiGetDescriptor, MultiGetQueryString, MultiGetResponse, IMultiGetResponse>(
+			return this.DispatchAsync<MultiGetDescriptor, MultiGetRequestParameters, MultiGetResponse, IMultiGetResponse>(
 				descriptor,
 				(p, d) => this.RawDispatch.MgetDispatchAsync<MultiGetResponse>(p, d, converter)
 			);
diff --git a/src/Nest/ElasticClient-MultiSearch.cs b/src/Nest/ElasticClient-MultiSearch.cs
index 529bcb8897f..7cce0837857 100644
--- a/src/Nest/ElasticClient-MultiSearch.cs
+++ b/src/Nest/ElasticClient-MultiSearch.cs
@@ -14,7 +14,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IMultiSearchResponse MultiSearch(Func<MultiSearchDescriptor, MultiSearchDescriptor> multiSearchSelector)
 		{
-			return this.Dispatch<MultiSearchDescriptor, MultiSearchQueryString, MultiSearchResponse>(
+			return this.Dispatch<MultiSearchDescriptor, MultiSearchRequestParameters, MultiSearchResponse>(
 				multiSearchSelector,
 				(p, d) =>
 				{
@@ -29,7 +29,7 @@ public IMultiSearchResponse MultiSearch(Func<MultiSearchDescriptor, MultiSearchD
 		public Task<IMultiSearchResponse> MultiSearchAsync(
 			Func<MultiSearchDescriptor, MultiSearchDescriptor> multiSearchSelector)
 		{
-			return this.DispatchAsync<MultiSearchDescriptor, MultiSearchQueryString, MultiSearchResponse, IMultiSearchResponse>(
+			return this.DispatchAsync<MultiSearchDescriptor, MultiSearchRequestParameters, MultiSearchResponse, IMultiSearchResponse>(
 				multiSearchSelector,
 				(p, d) =>
 				{
diff --git a/src/Nest/ElasticClient-Nodes.cs b/src/Nest/ElasticClient-Nodes.cs
index aa5daa22350..d14af1fa828 100644
--- a/src/Nest/ElasticClient-Nodes.cs
+++ b/src/Nest/ElasticClient-Nodes.cs
@@ -12,7 +12,7 @@ public partial class ElasticClient
 		public INodeInfoResponse NodesInfo(Func<NodesInfoDescriptor, NodesInfoDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.Dispatch<NodesInfoDescriptor, NodesInfoQueryString, NodeInfoResponse>(
+			return this.Dispatch<NodesInfoDescriptor, NodesInfoRequestParameters, NodeInfoResponse>(
 				selector,
 				(p, d) => this.RawDispatch.NodesInfoDispatch<NodeInfoResponse>(p)
 			);
@@ -22,7 +22,7 @@ public INodeInfoResponse NodesInfo(Func<NodesInfoDescriptor, NodesInfoDescriptor
 		public Task<INodeInfoResponse> NodesInfoAsync(Func<NodesInfoDescriptor, NodesInfoDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.DispatchAsync<NodesInfoDescriptor, NodesInfoQueryString, NodeInfoResponse, INodeInfoResponse>(
+			return this.DispatchAsync<NodesInfoDescriptor, NodesInfoRequestParameters, NodeInfoResponse, INodeInfoResponse>(
 				selector,
 				(p, d) => this.RawDispatch.NodesInfoDispatchAsync<NodeInfoResponse>(p)
 			);
@@ -32,7 +32,7 @@ public Task<INodeInfoResponse> NodesInfoAsync(Func<NodesInfoDescriptor, NodesInf
 		public INodeStatsResponse NodesStats(Func<NodesStatsDescriptor, NodesStatsDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.Dispatch<NodesStatsDescriptor, NodesStatsQueryString, NodeStatsResponse>(
+			return this.Dispatch<NodesStatsDescriptor, NodesStatsRequestParameters, NodeStatsResponse>(
 				selector,
 				(p, d) => this.RawDispatch.NodesStatsDispatch<NodeStatsResponse>(p)
 			);
@@ -42,7 +42,7 @@ public INodeStatsResponse NodesStats(Func<NodesStatsDescriptor, NodesStatsDescri
 		public Task<INodeStatsResponse> NodesStatsAsync(Func<NodesStatsDescriptor, NodesStatsDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.DispatchAsync<NodesStatsDescriptor, NodesStatsQueryString, NodeStatsResponse, INodeStatsResponse>(
+			return this.DispatchAsync<NodesStatsDescriptor, NodesStatsRequestParameters, NodeStatsResponse, INodeStatsResponse>(
 				selector,
 				(p, d) => this.RawDispatch.NodesStatsDispatchAsync<NodeStatsResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-OpenClose.cs b/src/Nest/ElasticClient-OpenClose.cs
index 8fb2792f064..7615cd2bf41 100644
--- a/src/Nest/ElasticClient-OpenClose.cs
+++ b/src/Nest/ElasticClient-OpenClose.cs
@@ -9,7 +9,7 @@ public partial class ElasticClient
 		/// <inheritdoc />
 		public IIndicesOperationResponse OpenIndex(Func<OpenIndexDescriptor, OpenIndexDescriptor> openIndexSelector)
 		{
-			return this.Dispatch<OpenIndexDescriptor, OpenIndexQueryString, IndicesOperationResponse>(
+			return this.Dispatch<OpenIndexDescriptor, OpenIndexRequestParameters, IndicesOperationResponse>(
 				openIndexSelector,
 				(p, d) => this.RawDispatch.IndicesOpenDispatch<IndicesOperationResponse>(p)
 			);
@@ -18,7 +18,7 @@ public IIndicesOperationResponse OpenIndex(Func<OpenIndexDescriptor, OpenIndexDe
 		/// <inheritdoc />
 		public Task<IIndicesOperationResponse> OpenIndexAsync(Func<OpenIndexDescriptor, OpenIndexDescriptor> openIndexSelector)
 		{
-			return this.DispatchAsync<OpenIndexDescriptor, OpenIndexQueryString, IndicesOperationResponse, IIndicesOperationResponse>(
+			return this.DispatchAsync<OpenIndexDescriptor, OpenIndexRequestParameters, IndicesOperationResponse, IIndicesOperationResponse>(
 				openIndexSelector,
 				(p, d) => this.RawDispatch.IndicesOpenDispatchAsync<IndicesOperationResponse>(p)
 			);
@@ -27,7 +27,7 @@ public Task<IIndicesOperationResponse> OpenIndexAsync(Func<OpenIndexDescriptor,
 		/// <inheritdoc />
 		public IIndicesOperationResponse CloseIndex(Func<CloseIndexDescriptor, CloseIndexDescriptor> closeIndexSelector)
 		{
-			return this.Dispatch<CloseIndexDescriptor, CloseIndexQueryString, IndicesOperationResponse>(
+			return this.Dispatch<CloseIndexDescriptor, CloseIndexRequestParameters, IndicesOperationResponse>(
 				closeIndexSelector,
 				(p, d) => this.RawDispatch.IndicesCloseDispatch<IndicesOperationResponse>(p)
 			);
@@ -38,7 +38,7 @@ public Task<IIndicesOperationResponse> CloseIndexAsync(
 			Func<CloseIndexDescriptor, CloseIndexDescriptor> closeIndexSelector)
 		{
 			return this.DispatchAsync
-				<CloseIndexDescriptor, CloseIndexQueryString, IndicesOperationResponse, IIndicesOperationResponse>(
+				<CloseIndexDescriptor, CloseIndexRequestParameters, IndicesOperationResponse, IIndicesOperationResponse>(
 					closeIndexSelector,
 					(p, d) => this.RawDispatch.IndicesCloseDispatchAsync<IndicesOperationResponse>(p)
 				);
diff --git a/src/Nest/ElasticClient-Optimize.cs b/src/Nest/ElasticClient-Optimize.cs
index de88566e583..aa4b3399d44 100644
--- a/src/Nest/ElasticClient-Optimize.cs
+++ b/src/Nest/ElasticClient-Optimize.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		public IShardsOperationResponse Optimize(Func<OptimizeDescriptor, OptimizeDescriptor> optimizeSelector = null)
 		{
 			optimizeSelector = optimizeSelector ?? (s => s);
-			return this.Dispatch<OptimizeDescriptor, OptimizeQueryString, ShardsOperationResponse>(
+			return this.Dispatch<OptimizeDescriptor, OptimizeRequestParameters, ShardsOperationResponse>(
 				optimizeSelector,
 				(p, d) => this.RawDispatch.IndicesOptimizeDispatch<ShardsOperationResponse>(p)
 			);
@@ -22,7 +22,7 @@ public Task<IShardsOperationResponse> OptimizeAsync(
 			Func<OptimizeDescriptor, OptimizeDescriptor> optimizeSelector = null)
 		{
 			optimizeSelector = optimizeSelector ?? (s => s);
-			return this.DispatchAsync<OptimizeDescriptor, OptimizeQueryString, ShardsOperationResponse, IShardsOperationResponse>(
+			return this.DispatchAsync<OptimizeDescriptor, OptimizeRequestParameters, ShardsOperationResponse, IShardsOperationResponse>(
 				optimizeSelector,
 				(p, d) => this.RawDispatch.IndicesOptimizeDispatchAsync<ShardsOperationResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-Percolate.cs b/src/Nest/ElasticClient-Percolate.cs
index 5add50b83f5..3ed82f03c68 100644
--- a/src/Nest/ElasticClient-Percolate.cs
+++ b/src/Nest/ElasticClient-Percolate.cs
@@ -12,7 +12,7 @@ public IUnregisterPercolateResponse UnregisterPercolator(string name,
 			Func<UnregisterPercolatorDescriptor, UnregisterPercolatorDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.Dispatch<UnregisterPercolatorDescriptor, DeleteQueryString, UnregisterPercolateResponse>(
+			return this.Dispatch<UnregisterPercolatorDescriptor, DeleteRequestParameters, UnregisterPercolateResponse>(
 				s => selector(s.Name(name)),
 				(p, d) => this.RawDispatch.DeleteDispatch<UnregisterPercolateResponse>(p), true
 			);
@@ -24,7 +24,7 @@ public Task<IUnregisterPercolateResponse> UnregisterPercolatorAsync(string name,
 		{
 			selector = selector ?? (s => s);
 			return this.DispatchAsync
-				<UnregisterPercolatorDescriptor, DeleteQueryString, UnregisterPercolateResponse, IUnregisterPercolateResponse>(
+				<UnregisterPercolatorDescriptor, DeleteRequestParameters, UnregisterPercolateResponse, IUnregisterPercolateResponse>(
 					s => selector(s.Name(name)),
 					(p, d) => this.RawDispatch.DeleteDispatchAsync<UnregisterPercolateResponse>(p), true
 				);
@@ -36,7 +36,7 @@ public IRegisterPercolateResponse RegisterPercolator<T>(string name,
 			where T : class
 		{
 			percolatorSelector.ThrowIfNull("percolatorSelector");
-			return this.Dispatch<RegisterPercolatorDescriptor<T>, IndexQueryString, RegisterPercolateResponse>(
+			return this.Dispatch<RegisterPercolatorDescriptor<T>, IndexRequestParameters, RegisterPercolateResponse>(
 				s => percolatorSelector(s.Name(name)),
 				(p, d) => this.RawDispatch.IndexDispatch<RegisterPercolateResponse>(p, d._RequestBody)
 			);
@@ -48,7 +48,7 @@ public Task<IRegisterPercolateResponse> RegisterPercolatorAsync<T>(string name,
 		{
 			percolatorSelector.ThrowIfNull("percolatorSelector");
 			return this.DispatchAsync
-				<RegisterPercolatorDescriptor<T>, IndexQueryString, RegisterPercolateResponse, IRegisterPercolateResponse>(
+				<RegisterPercolatorDescriptor<T>, IndexRequestParameters, RegisterPercolateResponse, IRegisterPercolateResponse>(
 					s => percolatorSelector(s.Name(name)),
 					(p, d) => this.RawDispatch.IndexDispatchAsync<RegisterPercolateResponse>(p, d._RequestBody)
 				);
@@ -77,7 +77,7 @@ public IPercolateResponse Percolate<T, K>(K @object,
 			where K : class
 		{
 			percolateSelector = percolateSelector ?? (s => s);
-			return this.Dispatch<PercolateDescriptor<T, K>, PercolateQueryString, PercolateResponse>(
+			return this.Dispatch<PercolateDescriptor<T, K>, PercolateRequestParameters, PercolateResponse>(
 				s => percolateSelector(s.Object(@object)),
 				(p, d) => this.RawDispatch.PercolateDispatch<PercolateResponse>(p, d)
 			);
@@ -90,7 +90,7 @@ public Task<IPercolateResponse> PercolateAsync<T, K>(K @object,
 			where K : class
 		{
 			percolateSelector = percolateSelector ?? (s => s);
-			return this.DispatchAsync<PercolateDescriptor<T, K>, PercolateQueryString, PercolateResponse, IPercolateResponse>(
+			return this.DispatchAsync<PercolateDescriptor<T, K>, PercolateRequestParameters, PercolateResponse, IPercolateResponse>(
 				s => percolateSelector(s.Object(@object)),
 				(p, d) => this.RawDispatch.PercolateDispatchAsync<PercolateResponse>(p, d)
 			);
diff --git a/src/Nest/ElasticClient-Refresh.cs b/src/Nest/ElasticClient-Refresh.cs
index 362302ca2e2..93212d6ea70 100644
--- a/src/Nest/ElasticClient-Refresh.cs
+++ b/src/Nest/ElasticClient-Refresh.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		public IShardsOperationResponse Refresh(Func<RefreshDescriptor, RefreshDescriptor> refreshSelector = null)
 		{
 			refreshSelector = refreshSelector ?? (s => s);
-			return this.Dispatch<RefreshDescriptor, RefreshQueryString, ShardsOperationResponse>(
+			return this.Dispatch<RefreshDescriptor, RefreshRequestParameters, ShardsOperationResponse>(
 				refreshSelector,
 				(p, d) => this.RawDispatch.IndicesRefreshDispatch<ShardsOperationResponse>(p)
 			);
@@ -21,7 +21,7 @@ public IShardsOperationResponse Refresh(Func<RefreshDescriptor, RefreshDescripto
 		public Task<IShardsOperationResponse> RefreshAsync(Func<RefreshDescriptor, RefreshDescriptor> refreshSelector = null)
 		{
 			refreshSelector = refreshSelector ?? (s => s);
-			return this.DispatchAsync<RefreshDescriptor, RefreshQueryString, ShardsOperationResponse, IShardsOperationResponse>(
+			return this.DispatchAsync<RefreshDescriptor, RefreshRequestParameters, ShardsOperationResponse, IShardsOperationResponse>(
 				refreshSelector,
 				(p, d) => this.RawDispatch.IndicesRefreshDispatchAsync<ShardsOperationResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-RootNodeInfo.cs b/src/Nest/ElasticClient-RootNodeInfo.cs
index d16c16fe29f..9296f8c3b95 100644
--- a/src/Nest/ElasticClient-RootNodeInfo.cs
+++ b/src/Nest/ElasticClient-RootNodeInfo.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		public IRootInfoResponse RootNodeInfo(Func<InfoDescriptor, InfoDescriptor> selector = null)
 		{
 			selector = selector ?? (i => i);
-			return this.Dispatch<InfoDescriptor, InfoQueryString, RootInfoResponse>(
+			return this.Dispatch<InfoDescriptor, InfoRequestParameters, RootInfoResponse>(
 				selector,
 				(p, d) => this.RawDispatch.InfoDispatch<RootInfoResponse>(p)
 			);
@@ -21,7 +21,7 @@ public IRootInfoResponse RootNodeInfo(Func<InfoDescriptor, InfoDescriptor> selec
 		public Task<IRootInfoResponse> RootNodeInfoAsync(Func<InfoDescriptor, InfoDescriptor> selector = null)
 		{
 			selector = selector ?? (i => i);
-			return this.DispatchAsync<InfoDescriptor, InfoQueryString, RootInfoResponse, IRootInfoResponse>(
+			return this.DispatchAsync<InfoDescriptor, InfoRequestParameters, RootInfoResponse, IRootInfoResponse>(
 				selector,
 				(p, d) => this.RawDispatch.InfoDispatchAsync<RootInfoResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-Scroll.cs b/src/Nest/ElasticClient-Scroll.cs
index 94726349ca8..1ab908a0432 100644
--- a/src/Nest/ElasticClient-Scroll.cs
+++ b/src/Nest/ElasticClient-Scroll.cs
@@ -11,7 +11,7 @@ public IQueryResponse<T> Scroll<T>(
 			Func<ScrollDescriptor<T>, ScrollDescriptor<T>> scrollSelector)
 			where T : class
 		{
-			return this.Dispatch<ScrollDescriptor<T>, ScrollQueryString, QueryResponse<T>>(
+			return this.Dispatch<ScrollDescriptor<T>, ScrollRequestParameters, QueryResponse<T>>(
 				scrollSelector,
 				(p, d) =>
 				{
@@ -27,7 +27,7 @@ public Task<IQueryResponse<T>> ScrollAsync<T>(
 			Func<ScrollDescriptor<T>, ScrollDescriptor<T>> scrollSelector)
 			where T : class
 		{
-			return this.DispatchAsync<ScrollDescriptor<T>, ScrollQueryString, QueryResponse<T>, IQueryResponse<T>>(
+			return this.DispatchAsync<ScrollDescriptor<T>, ScrollRequestParameters, QueryResponse<T>, IQueryResponse<T>>(
 				scrollSelector,
 				(p, d) =>
 				{
diff --git a/src/Nest/ElasticClient-Search.cs b/src/Nest/ElasticClient-Search.cs
index 8042bc3b38f..6ef1d7f4cde 100644
--- a/src/Nest/ElasticClient-Search.cs
+++ b/src/Nest/ElasticClient-Search.cs
@@ -24,7 +24,7 @@ public IQueryResponse<TResult> Search<T, TResult>(Func<SearchDescriptor<T>, Sear
 			searchSelector.ThrowIfNull("searchSelector");
 			var descriptor = searchSelector(new SearchDescriptor<T>());
 			var pathInfo =
-				((IPathInfo<SearchQueryString>) descriptor).ToPathInfo(_connectionSettings);
+				((IPathInfo<SearchRequestParameters>) descriptor).ToPathInfo(_connectionSettings);
 			var deserializationState = this.CreateCovariantSearchSelector<T, TResult>(descriptor);
 			var status = this.RawDispatch.SearchDispatch<QueryResponse<TResult>>(pathInfo,
 				descriptor, deserializationState);
@@ -48,7 +48,7 @@ public Task<IQueryResponse<TResult>> SearchAsync<T, TResult>(
 			searchSelector.ThrowIfNull("searchSelector");
 			var descriptor = searchSelector(new SearchDescriptor<T>());
 			var pathInfo =
-				((IPathInfo<SearchQueryString>) descriptor).ToPathInfo(_connectionSettings);
+				((IPathInfo<SearchRequestParameters>) descriptor).ToPathInfo(_connectionSettings);
 			var deserializationState = this.CreateCovariantSearchSelector<T, TResult>(descriptor);
 			return this.RawDispatch.SearchDispatchAsync<QueryResponse<TResult>>(pathInfo, descriptor, deserializationState)
 				.ContinueWith<IQueryResponse<TResult>>(t => t.Result.Success
diff --git a/src/Nest/ElasticClient-Segments.cs b/src/Nest/ElasticClient-Segments.cs
index 83cbcb4b487..74fceb4a725 100644
--- a/src/Nest/ElasticClient-Segments.cs
+++ b/src/Nest/ElasticClient-Segments.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		public ISegmentsResponse Segments(Func<SegmentsDescriptor, SegmentsDescriptor> segmentsSelector = null)
 		{
 			segmentsSelector = segmentsSelector ?? (s => s);
-			return this.Dispatch<SegmentsDescriptor, SegmentsQueryString, SegmentsResponse>(
+			return this.Dispatch<SegmentsDescriptor, SegmentsRequestParameters, SegmentsResponse>(
 				segmentsSelector,
 				(p, d) => this.RawDispatch.IndicesSegmentsDispatch<SegmentsResponse>(p)
 			);
@@ -21,7 +21,7 @@ public ISegmentsResponse Segments(Func<SegmentsDescriptor, SegmentsDescriptor> s
 		public Task<ISegmentsResponse> SegmentsAsync(Func<SegmentsDescriptor, SegmentsDescriptor> segmentsSelector = null)
 		{
 			segmentsSelector = segmentsSelector ?? (s => s);
-			return this.DispatchAsync<SegmentsDescriptor, SegmentsQueryString, SegmentsResponse, ISegmentsResponse>(
+			return this.DispatchAsync<SegmentsDescriptor, SegmentsRequestParameters, SegmentsResponse, ISegmentsResponse>(
 				segmentsSelector,
 				(p, d) => this.RawDispatch.IndicesSegmentsDispatchAsync<SegmentsResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-Source.cs b/src/Nest/ElasticClient-Source.cs
index 93471195a89..b48c0f9380a 100644
--- a/src/Nest/ElasticClient-Source.cs
+++ b/src/Nest/ElasticClient-Source.cs
@@ -13,7 +13,7 @@ public T Source<T>(Func<SourceDescriptor<T>, SourceDescriptor<T>> getSelector) w
 		{
 			var descriptor = getSelector(new SourceDescriptor<T>());
 			var pathInfo =
-				((IPathInfo<SourceQueryString>) descriptor).ToPathInfo(_connectionSettings);
+				((IPathInfo<SourceRequestParameters>) descriptor).ToPathInfo(_connectionSettings);
 			var response = this.RawDispatch.GetSourceDispatch<T>(pathInfo);
 			return response.Response;
 		}
@@ -23,7 +23,7 @@ public Task<T> SourceAsync<T>(Func<SourceDescriptor<T>, SourceDescriptor<T>> get
 		{
 			var descriptor = getSelector(new SourceDescriptor<T>());
 			var pathInfo =
-				((IPathInfo<SourceQueryString>) descriptor).ToPathInfo(_connectionSettings);
+				((IPathInfo<SourceRequestParameters>) descriptor).ToPathInfo(_connectionSettings);
 			var response = this.RawDispatch.GetSourceDispatchAsync<T>(pathInfo)
 				.ContinueWith(t => t.Result.Response);
 			return response;
diff --git a/src/Nest/ElasticClient-State.cs b/src/Nest/ElasticClient-State.cs
index 2ea48d46d98..b19477f22fe 100644
--- a/src/Nest/ElasticClient-State.cs
+++ b/src/Nest/ElasticClient-State.cs
@@ -12,7 +12,7 @@ public IClusterStateResponse ClusterState(
 			Func<ClusterStateDescriptor, ClusterStateDescriptor> clusterStateSelector = null)
 		{
 			clusterStateSelector = clusterStateSelector ?? (s => s);
-			return this.Dispatch<ClusterStateDescriptor, ClusterStateQueryString, ClusterStateResponse>(
+			return this.Dispatch<ClusterStateDescriptor, ClusterStateRequestParameters, ClusterStateResponse>(
 				clusterStateSelector,
 				(p, d) => this.RawDispatch.ClusterStateDispatch<ClusterStateResponse>(p)
 			);
@@ -23,7 +23,7 @@ public Task<IClusterStateResponse> ClusterStateAsync(
 			Func<ClusterStateDescriptor, ClusterStateDescriptor> clusterStateSelector = null)
 		{
 			clusterStateSelector = clusterStateSelector ?? (s => s);
-			return this.DispatchAsync<ClusterStateDescriptor, ClusterStateQueryString, ClusterStateResponse, IClusterStateResponse>(
+			return this.DispatchAsync<ClusterStateDescriptor, ClusterStateRequestParameters, ClusterStateResponse, IClusterStateResponse>(
 				clusterStateSelector,
 				(p, d) => this.RawDispatch.ClusterStateDispatchAsync<ClusterStateResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-Stats.cs b/src/Nest/ElasticClient-Stats.cs
index edf8b23ce2a..e36af38e213 100644
--- a/src/Nest/ElasticClient-Stats.cs
+++ b/src/Nest/ElasticClient-Stats.cs
@@ -12,7 +12,7 @@ public partial class ElasticClient
 		public IGlobalStatsResponse IndicesStats(Func<IndicesStatsDescriptor, IndicesStatsDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.Dispatch<IndicesStatsDescriptor, IndicesStatsQueryString, GlobalStatsResponse>(
+			return this.Dispatch<IndicesStatsDescriptor, IndicesStatsRequestParameters, GlobalStatsResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesStatsDispatch<GlobalStatsResponse>(p)
 			);
@@ -23,7 +23,7 @@ public Task<IGlobalStatsResponse> IndicesStatsAsync(
 			Func<IndicesStatsDescriptor, IndicesStatsDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.DispatchAsync<IndicesStatsDescriptor, IndicesStatsQueryString, GlobalStatsResponse, IGlobalStatsResponse>(
+			return this.DispatchAsync<IndicesStatsDescriptor, IndicesStatsRequestParameters, GlobalStatsResponse, IGlobalStatsResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesStatsDispatchAsync<GlobalStatsResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-Status.cs b/src/Nest/ElasticClient-Status.cs
index 7b0274e4469..029bd16c522 100644
--- a/src/Nest/ElasticClient-Status.cs
+++ b/src/Nest/ElasticClient-Status.cs
@@ -13,7 +13,7 @@ public partial class ElasticClient
 		public IStatusResponse Status(Func<IndicesStatusDescriptor, IndicesStatusDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.Dispatch<IndicesStatusDescriptor, IndicesStatusQueryString, StatusResponse>(
+			return this.Dispatch<IndicesStatusDescriptor, IndicesStatusRequestParameters, StatusResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesStatusDispatch<StatusResponse>(p)
 			);
@@ -23,7 +23,7 @@ public IStatusResponse Status(Func<IndicesStatusDescriptor, IndicesStatusDescrip
 		public Task<IStatusResponse> StatusAsync(Func<IndicesStatusDescriptor, IndicesStatusDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.DispatchAsync<IndicesStatusDescriptor, IndicesStatusQueryString, StatusResponse, IStatusResponse>(
+			return this.DispatchAsync<IndicesStatusDescriptor, IndicesStatusRequestParameters, StatusResponse, IStatusResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesStatusDispatchAsync<StatusResponse>(p)
 			);
diff --git a/src/Nest/ElasticClient-Template.cs b/src/Nest/ElasticClient-Template.cs
index 1e5f559a469..05d2055ce08 100644
--- a/src/Nest/ElasticClient-Template.cs
+++ b/src/Nest/ElasticClient-Template.cs
@@ -16,7 +16,7 @@ public ITemplateResponse GetTemplate(string name,
 			Func<GetTemplateDescriptor, GetTemplateDescriptor> getTemplateSelector = null)
 		{
 			getTemplateSelector = getTemplateSelector ?? (s => s);
-			return this.Dispatch<GetTemplateDescriptor, GetTemplateQueryString, TemplateResponse>(
+			return this.Dispatch<GetTemplateDescriptor, GetTemplateRequestParameters, TemplateResponse>(
 				d => getTemplateSelector(d.Name(name)),
 				(p, d) =>
 					RawDispatch.IndicesGetTemplateDispatch<TemplateResponse>(p, (GetTemplateConverter) DeserializeTemplateResponse)
@@ -28,7 +28,7 @@ public Task<ITemplateResponse> GetTemplateAsync(string name,
 			Func<GetTemplateDescriptor, GetTemplateDescriptor> getTemplateSelector = null)
 		{
 			getTemplateSelector = getTemplateSelector ?? (s => s);
-			return this.DispatchAsync<GetTemplateDescriptor, GetTemplateQueryString, TemplateResponse, ITemplateResponse>(
+			return this.DispatchAsync<GetTemplateDescriptor, GetTemplateRequestParameters, TemplateResponse, ITemplateResponse>(
 				d => getTemplateSelector(d.Name(name)),
 				(p, d) => this.RawDispatch.IndicesGetTemplateDispatchAsync<TemplateResponse>(
 					p, (GetTemplateConverter) DeserializeTemplateResponse)
@@ -41,7 +41,7 @@ public IIndicesOperationResponse PutTemplate(string name,
 		{
 			putTemplateSelector.ThrowIfNull("putTemplateSelector");
 			var descriptor = putTemplateSelector(new PutTemplateDescriptor(_connectionSettings).Name(name));
-			return this.Dispatch<PutTemplateDescriptor, PutTemplateQueryString, IndicesOperationResponse>(
+			return this.Dispatch<PutTemplateDescriptor, PutTemplateRequestParameters, IndicesOperationResponse>(
 				descriptor,
 				(p, d) => this.RawDispatch.IndicesPutTemplateDispatch<IndicesOperationResponse>(p, d._TemplateMapping)
 			);
@@ -54,7 +54,7 @@ public Task<IIndicesOperationResponse> PutTemplateAsync(string name,
 			putTemplateSelector.ThrowIfNull("putTemplateSelector");
 			var descriptor = putTemplateSelector(new PutTemplateDescriptor(_connectionSettings).Name(name));
 			return this.DispatchAsync
-				<PutTemplateDescriptor, PutTemplateQueryString, IndicesOperationResponse, IIndicesOperationResponse>(
+				<PutTemplateDescriptor, PutTemplateRequestParameters, IndicesOperationResponse, IIndicesOperationResponse>(
 					descriptor,
 					(p, d) => this.RawDispatch.IndicesPutTemplateDispatchAsync<IndicesOperationResponse>(p, d._TemplateMapping)
 				);
@@ -65,7 +65,7 @@ public IIndicesOperationResponse DeleteTemplate(string name,
 			Func<DeleteTemplateDescriptor, DeleteTemplateDescriptor> deleteTemplateSelector = null)
 		{
 			deleteTemplateSelector = deleteTemplateSelector ?? (s => s);
-			return this.Dispatch<DeleteTemplateDescriptor, DeleteTemplateQueryString, IndicesOperationResponse>(
+			return this.Dispatch<DeleteTemplateDescriptor, DeleteTemplateRequestParameters, IndicesOperationResponse>(
 				d => deleteTemplateSelector(d.Name(name)),
 				(p, d) => this.RawDispatch.IndicesDeleteTemplateDispatch<IndicesOperationResponse>(p)
 			);
@@ -77,7 +77,7 @@ public Task<IIndicesOperationResponse> DeleteTemplateAync(string name,
 		{
 			deleteTemplateSelector = deleteTemplateSelector ?? (s => s);
 			return this.DispatchAsync
-				<DeleteTemplateDescriptor, DeleteTemplateQueryString, IndicesOperationResponse, IIndicesOperationResponse>(
+				<DeleteTemplateDescriptor, DeleteTemplateRequestParameters, IndicesOperationResponse, IIndicesOperationResponse>(
 					d => deleteTemplateSelector(d.Name(name)),
 					(p, d) => this.RawDispatch.IndicesDeleteTemplateDispatchAsync<IndicesOperationResponse>(p)
 				);
diff --git a/src/Nest/ElasticClient-Update.cs b/src/Nest/ElasticClient-Update.cs
index b374f6c730b..5bef2365321 100644
--- a/src/Nest/ElasticClient-Update.cs
+++ b/src/Nest/ElasticClient-Update.cs
@@ -18,7 +18,7 @@ public IUpdateResponse Update<T, K>(Func<UpdateDescriptor<T, K>, UpdateDescripto
 			where T : class
 			where K : class
 		{
-			return this.Dispatch<UpdateDescriptor<T, K>, UpdateQueryString, UpdateResponse>(
+			return this.Dispatch<UpdateDescriptor<T, K>, UpdateRequestParameters, UpdateResponse>(
 				updateSelector,
 				(p, d) => this.RawDispatch.UpdateDispatch<UpdateResponse>(p, d)
 			);
@@ -36,7 +36,7 @@ public Task<IUpdateResponse> UpdateAsync<T, K>(Func<UpdateDescriptor<T, K>, Upda
 			where T : class
 			where K : class
 		{
-			return this.DispatchAsync<UpdateDescriptor<T, K>, UpdateQueryString, UpdateResponse, IUpdateResponse>(
+			return this.DispatchAsync<UpdateDescriptor<T, K>, UpdateRequestParameters, UpdateResponse, IUpdateResponse>(
 				updateSelector,
 				(p, d) => this.RawDispatch.UpdateDispatchAsync<UpdateResponse>(p, d)
 			);
diff --git a/src/Nest/ElasticClient-UpdateSettings.cs b/src/Nest/ElasticClient-UpdateSettings.cs
index 96e6a6c0978..a8f3d35ca72 100644
--- a/src/Nest/ElasticClient-UpdateSettings.cs
+++ b/src/Nest/ElasticClient-UpdateSettings.cs
@@ -13,7 +13,7 @@ public ISettingsOperationResponse UpdateSettings(
 			Func<UpdateSettingsDescriptor, UpdateSettingsDescriptor> updateSettingsSelector
 			)
 		{
-			return this.Dispatch<UpdateSettingsDescriptor, UpdateSettingsQueryString, SettingsOperationResponse>(
+			return this.Dispatch<UpdateSettingsDescriptor, UpdateSettingsRequestParameters, SettingsOperationResponse>(
 				updateSettingsSelector,
 				(p, d) => this.RawDispatch.IndicesPutSettingsDispatch<SettingsOperationResponse>(p, d)
 			);
@@ -25,7 +25,7 @@ Func<UpdateSettingsDescriptor, UpdateSettingsDescriptor> updateSettingsSelector
 			)
 		{
 			return this.DispatchAsync
-				<UpdateSettingsDescriptor, UpdateSettingsQueryString, SettingsOperationResponse, ISettingsOperationResponse>(
+				<UpdateSettingsDescriptor, UpdateSettingsRequestParameters, SettingsOperationResponse, ISettingsOperationResponse>(
 					updateSettingsSelector,
 					(p, d) => this.RawDispatch.IndicesPutSettingsDispatchAsync<SettingsOperationResponse>(p, d)
 				);
diff --git a/src/Nest/ElasticClient-Validate.cs b/src/Nest/ElasticClient-Validate.cs
index 65b1a40c948..ad65a3fc97b 100644
--- a/src/Nest/ElasticClient-Validate.cs
+++ b/src/Nest/ElasticClient-Validate.cs
@@ -11,7 +11,7 @@ public partial class ElasticClient
 		public IValidateResponse Validate<T>(Func<ValidateQueryDescriptor<T>, ValidateQueryDescriptor<T>> querySelector)
 			where T : class
 		{
-			return this.Dispatch<ValidateQueryDescriptor<T>, ValidateQueryQueryString, ValidateResponse>(
+			return this.Dispatch<ValidateQueryDescriptor<T>, ValidateQueryRequestParameters, ValidateResponse>(
 				querySelector,
 				(p, d) => this.RawDispatch.IndicesValidateQueryDispatch<ValidateResponse>(p, d)
 			);
@@ -22,7 +22,7 @@ public Task<IValidateResponse> ValidateAsync<T>(
 			Func<ValidateQueryDescriptor<T>, ValidateQueryDescriptor<T>> querySelector)
 			where T : class
 		{
-			return this.DispatchAsync<ValidateQueryDescriptor<T>, ValidateQueryQueryString, ValidateResponse, IValidateResponse>(
+			return this.DispatchAsync<ValidateQueryDescriptor<T>, ValidateQueryRequestParameters, ValidateResponse, IValidateResponse>(
 				querySelector,
 				(p, d) => this.RawDispatch.IndicesValidateQueryDispatchAsync<ValidateResponse>(p, d)
 			);
diff --git a/src/Nest/ElasticClient-Warmers.cs b/src/Nest/ElasticClient-Warmers.cs
index d5d7356fadb..1c4a413bd8a 100644
--- a/src/Nest/ElasticClient-Warmers.cs
+++ b/src/Nest/ElasticClient-Warmers.cs
@@ -16,7 +16,7 @@ public partial class ElasticClient
 		public IIndicesOperationResponse PutWarmer(string name, Func<PutWarmerDescriptor, PutWarmerDescriptor> selector)
 		{
 			selector.ThrowIfNull("selector");
-			return this.Dispatch<PutWarmerDescriptor, PutWarmerQueryString, IndicesOperationResponse>(
+			return this.Dispatch<PutWarmerDescriptor, PutWarmerRequestParameters, IndicesOperationResponse>(
 				d => selector(d.Name(name).AllIndices()),
 				(p, d) => this.RawDispatch.IndicesPutWarmerDispatch<IndicesOperationResponse>(p, d)
 			);
@@ -27,7 +27,7 @@ public Task<IIndicesOperationResponse> PutWarmerAsync(string name,
 			Func<PutWarmerDescriptor, PutWarmerDescriptor> selector)
 		{
 			selector.ThrowIfNull("selector");
-			return this.DispatchAsync<PutWarmerDescriptor, PutWarmerQueryString, IndicesOperationResponse, IIndicesOperationResponse>(
+			return this.DispatchAsync<PutWarmerDescriptor, PutWarmerRequestParameters, IndicesOperationResponse, IIndicesOperationResponse>(
 				d => selector(d.Name(name).AllIndices()),
 				(p, d) => this.RawDispatch.IndicesPutWarmerDispatchAsync<IndicesOperationResponse>(p, d)
 			);
@@ -37,7 +37,7 @@ public Task<IIndicesOperationResponse> PutWarmerAsync(string name,
 		public IWarmerResponse GetWarmer(string name, Func<GetWarmerDescriptor, GetWarmerDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.Dispatch<GetWarmerDescriptor, GetWarmerQueryString, WarmerResponse>(
+			return this.Dispatch<GetWarmerDescriptor, GetWarmerRequestParameters, WarmerResponse>(
 				d => selector(d.Name(name).AllIndices()),
 				(p, d) => this.RawDispatch.IndicesGetWarmerDispatch<WarmerResponse>(
 					p,
@@ -51,7 +51,7 @@ public Task<IWarmerResponse> GetWarmerAsync(string name,
 			Func<GetWarmerDescriptor, GetWarmerDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.DispatchAsync<GetWarmerDescriptor, GetWarmerQueryString, WarmerResponse, IWarmerResponse>(
+			return this.DispatchAsync<GetWarmerDescriptor, GetWarmerRequestParameters, WarmerResponse, IWarmerResponse>(
 				d => selector(d.Name(name).AllIndices()),
 				(p, d) => this.RawDispatch.IndicesGetWarmerDispatchAsync<WarmerResponse>(
 					p,
@@ -65,7 +65,7 @@ public IIndicesOperationResponse DeleteWarmer(string name,
 			Func<DeleteWarmerDescriptor, DeleteWarmerDescriptor> selector = null)
 		{
 			selector = selector ?? (s => s);
-			return this.Dispatch<DeleteWarmerDescriptor, DeleteWarmerQueryString, IndicesOperationResponse>(
+			return this.Dispatch<DeleteWarmerDescriptor, DeleteWarmerRequestParameters, IndicesOperationResponse>(
 				d => selector(d.Name(name).AllIndices()),
 				(p, d) => this.RawDispatch.IndicesDeleteWarmerDispatch<IndicesOperationResponse>(p)
 			);
@@ -77,7 +77,7 @@ public Task<IIndicesOperationResponse> DeleteWarmerAsync(string name,
 		{
 			selector = selector ?? (s => s);
 			return this.DispatchAsync
-				<DeleteWarmerDescriptor, DeleteWarmerQueryString, IndicesOperationResponse, IIndicesOperationResponse>(
+				<DeleteWarmerDescriptor, DeleteWarmerRequestParameters, IndicesOperationResponse, IIndicesOperationResponse>(
 					d => selector(d.Name(name).AllIndices()),
 					(p, d) => this.RawDispatch.IndicesDeleteWarmerDispatchAsync<IndicesOperationResponse>(p)
 				);
diff --git a/src/Nest/ElasticClient.cs b/src/Nest/ElasticClient.cs
index 15de273f0bf..d4e6541a631 100644
--- a/src/Nest/ElasticClient.cs
+++ b/src/Nest/ElasticClient.cs
@@ -63,7 +63,7 @@ Func<D, D> selector
 			, Func<ElasticsearchPathInfo<Q>, D, ElasticsearchResponse<R>> dispatch
 			, bool allow404 = false
 			)
-			where Q : FluentQueryString<Q>, new()
+			where Q : FluentRequestParameters<Q>, new()
 			where D : IPathInfo<Q>, new()
 			where R : BaseResponse
 		{
@@ -78,7 +78,7 @@ D descriptor
 			, Func<ElasticsearchPathInfo<Q>, D, ElasticsearchResponse<R>> dispatch
 			, bool allow404 = false
 			)
-			where Q : FluentQueryString<Q>, new()
+			where Q : FluentRequestParameters<Q>, new()
 			where D : IPathInfo<Q>
 			where R : BaseResponse
 		{
@@ -104,7 +104,7 @@ Func<D, D> selector
 			, Func<ElasticsearchPathInfo<Q>, D, Task<ElasticsearchResponse<R>>> dispatch
 			, bool allow404 = false
 			)
-			where Q : FluentQueryString<Q>, new()
+			where Q : FluentRequestParameters<Q>, new()
 			where D : IPathInfo<Q>, new()
 			where R : BaseResponse, I
 			where I : IResponse
@@ -119,7 +119,7 @@ D descriptor
 			, Func<ElasticsearchPathInfo<Q>, D, Task<ElasticsearchResponse<R>>> dispatch
 			, bool allow404 = false
 			) 
-			where Q : FluentQueryString<Q>, new()
+			where Q : FluentRequestParameters<Q>, new()
 			where D : IPathInfo<Q>
 			where R : BaseResponse, I 
 			where I : IResponse
diff --git a/src/Nest/Nest.csproj b/src/Nest/Nest.csproj
index c536e3cd9be..8cb35b5359b 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -128,7 +128,7 @@
     <Compile Include="Domain\ICustomJson.cs" />
     <Compile Include="Domain\PropertyNameMarker.cs" />
     <Compile Include="Domain\PropertyPathMarker.cs" />
-    <Compile Include="Domain\QueryStringParametersExtensions.Generated.cs" />
+    <Compile Include="Domain\RequestParametersExtensions.Generated.cs" />
     <Compile Include="Domain\Responses\GetAliasesResponse.cs" />
     <Compile Include="Domain\Responses\GetMappingResponse.cs" />
     <Compile Include="Domain\Responses\IMultiSearchResponse.cs" />
diff --git a/src/Nest/RawDispatch.generated.cs b/src/Nest/RawDispatch.generated.cs
index 8875308afca..6490a7d539d 100644
--- a/src/Nest/RawDispatch.generated.cs
+++ b/src/Nest/RawDispatch.generated.cs
@@ -18,7 +18,7 @@ internal partial class RawDispatch
 	{
 	
 		
-		internal ElasticsearchResponse<T> BulkDispatch<T>(ElasticsearchPathInfo<BulkQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> BulkDispatch<T>(ElasticsearchPathInfo<BulkRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -51,7 +51,7 @@ internal ElasticsearchResponse<T> BulkDispatch<T>(ElasticsearchPathInfo<BulkQuer
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> BulkDispatchAsync<T>(ElasticsearchPathInfo<BulkQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> BulkDispatchAsync<T>(ElasticsearchPathInfo<BulkRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -84,7 +84,7 @@ internal Task<ElasticsearchResponse<T>> BulkDispatchAsync<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatAliasesDispatch<T>(ElasticsearchPathInfo<CatAliasesQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatAliasesDispatch<T>(ElasticsearchPathInfo<CatAliasesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -100,7 +100,7 @@ internal ElasticsearchResponse<T> CatAliasesDispatch<T>(ElasticsearchPathInfo<Ca
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatAliasesDispatchAsync<T>(ElasticsearchPathInfo<CatAliasesQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatAliasesDispatchAsync<T>(ElasticsearchPathInfo<CatAliasesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -116,7 +116,7 @@ internal Task<ElasticsearchResponse<T>> CatAliasesDispatchAsync<T>(Elasticsearch
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatAllocationDispatch<T>(ElasticsearchPathInfo<CatAllocationQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatAllocationDispatch<T>(ElasticsearchPathInfo<CatAllocationRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -132,7 +132,7 @@ internal ElasticsearchResponse<T> CatAllocationDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatAllocationDispatchAsync<T>(ElasticsearchPathInfo<CatAllocationQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatAllocationDispatchAsync<T>(ElasticsearchPathInfo<CatAllocationRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -148,7 +148,7 @@ internal Task<ElasticsearchResponse<T>> CatAllocationDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatCountDispatch<T>(ElasticsearchPathInfo<CatCountQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatCountDispatch<T>(ElasticsearchPathInfo<CatCountRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -164,7 +164,7 @@ internal ElasticsearchResponse<T> CatCountDispatch<T>(ElasticsearchPathInfo<CatC
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatCountDispatchAsync<T>(ElasticsearchPathInfo<CatCountQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatCountDispatchAsync<T>(ElasticsearchPathInfo<CatCountRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -180,7 +180,7 @@ internal Task<ElasticsearchResponse<T>> CatCountDispatchAsync<T>(ElasticsearchPa
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatHealthDispatch<T>(ElasticsearchPathInfo<CatHealthQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatHealthDispatch<T>(ElasticsearchPathInfo<CatHealthRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -193,7 +193,7 @@ internal ElasticsearchResponse<T> CatHealthDispatch<T>(ElasticsearchPathInfo<Cat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatHealthDispatchAsync<T>(ElasticsearchPathInfo<CatHealthQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatHealthDispatchAsync<T>(ElasticsearchPathInfo<CatHealthRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -206,7 +206,7 @@ internal Task<ElasticsearchResponse<T>> CatHealthDispatchAsync<T>(ElasticsearchP
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatHelpDispatch<T>(ElasticsearchPathInfo<CatHelpQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatHelpDispatch<T>(ElasticsearchPathInfo<CatHelpRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -219,7 +219,7 @@ internal ElasticsearchResponse<T> CatHelpDispatch<T>(ElasticsearchPathInfo<CatHe
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatHelpDispatchAsync<T>(ElasticsearchPathInfo<CatHelpQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatHelpDispatchAsync<T>(ElasticsearchPathInfo<CatHelpRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -232,7 +232,7 @@ internal Task<ElasticsearchResponse<T>> CatHelpDispatchAsync<T>(ElasticsearchPat
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatIndicesDispatch<T>(ElasticsearchPathInfo<CatIndicesQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatIndicesDispatch<T>(ElasticsearchPathInfo<CatIndicesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -248,7 +248,7 @@ internal ElasticsearchResponse<T> CatIndicesDispatch<T>(ElasticsearchPathInfo<Ca
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatIndicesDispatchAsync<T>(ElasticsearchPathInfo<CatIndicesQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatIndicesDispatchAsync<T>(ElasticsearchPathInfo<CatIndicesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -264,7 +264,7 @@ internal Task<ElasticsearchResponse<T>> CatIndicesDispatchAsync<T>(Elasticsearch
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatMasterDispatch<T>(ElasticsearchPathInfo<CatMasterQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatMasterDispatch<T>(ElasticsearchPathInfo<CatMasterRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -277,7 +277,7 @@ internal ElasticsearchResponse<T> CatMasterDispatch<T>(ElasticsearchPathInfo<Cat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatMasterDispatchAsync<T>(ElasticsearchPathInfo<CatMasterQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatMasterDispatchAsync<T>(ElasticsearchPathInfo<CatMasterRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -290,7 +290,7 @@ internal Task<ElasticsearchResponse<T>> CatMasterDispatchAsync<T>(ElasticsearchP
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatNodesDispatch<T>(ElasticsearchPathInfo<CatNodesQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatNodesDispatch<T>(ElasticsearchPathInfo<CatNodesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -303,7 +303,7 @@ internal ElasticsearchResponse<T> CatNodesDispatch<T>(ElasticsearchPathInfo<CatN
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatNodesDispatchAsync<T>(ElasticsearchPathInfo<CatNodesQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatNodesDispatchAsync<T>(ElasticsearchPathInfo<CatNodesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -316,7 +316,7 @@ internal Task<ElasticsearchResponse<T>> CatNodesDispatchAsync<T>(ElasticsearchPa
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatPendingTasksDispatch<T>(ElasticsearchPathInfo<CatPendingTasksQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatPendingTasksDispatch<T>(ElasticsearchPathInfo<CatPendingTasksRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -329,7 +329,7 @@ internal ElasticsearchResponse<T> CatPendingTasksDispatch<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatPendingTasksDispatchAsync<T>(ElasticsearchPathInfo<CatPendingTasksQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatPendingTasksDispatchAsync<T>(ElasticsearchPathInfo<CatPendingTasksRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -342,7 +342,7 @@ internal Task<ElasticsearchResponse<T>> CatPendingTasksDispatchAsync<T>(Elastics
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatRecoveryDispatch<T>(ElasticsearchPathInfo<CatRecoveryQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatRecoveryDispatch<T>(ElasticsearchPathInfo<CatRecoveryRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -358,7 +358,7 @@ internal ElasticsearchResponse<T> CatRecoveryDispatch<T>(ElasticsearchPathInfo<C
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatRecoveryDispatchAsync<T>(ElasticsearchPathInfo<CatRecoveryQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatRecoveryDispatchAsync<T>(ElasticsearchPathInfo<CatRecoveryRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -374,7 +374,7 @@ internal Task<ElasticsearchResponse<T>> CatRecoveryDispatchAsync<T>(Elasticsearc
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatShardsDispatch<T>(ElasticsearchPathInfo<CatShardsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatShardsDispatch<T>(ElasticsearchPathInfo<CatShardsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -390,7 +390,7 @@ internal ElasticsearchResponse<T> CatShardsDispatch<T>(ElasticsearchPathInfo<Cat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatShardsDispatchAsync<T>(ElasticsearchPathInfo<CatShardsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatShardsDispatchAsync<T>(ElasticsearchPathInfo<CatShardsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -406,7 +406,7 @@ internal Task<ElasticsearchResponse<T>> CatShardsDispatchAsync<T>(ElasticsearchP
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatThreadPoolDispatch<T>(ElasticsearchPathInfo<CatThreadPoolQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatThreadPoolDispatch<T>(ElasticsearchPathInfo<CatThreadPoolRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -419,7 +419,7 @@ internal ElasticsearchResponse<T> CatThreadPoolDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatThreadPoolDispatchAsync<T>(ElasticsearchPathInfo<CatThreadPoolQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatThreadPoolDispatchAsync<T>(ElasticsearchPathInfo<CatThreadPoolRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -432,7 +432,7 @@ internal Task<ElasticsearchResponse<T>> CatThreadPoolDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClearScrollDispatch<T>(ElasticsearchPathInfo<ClearScrollQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClearScrollDispatch<T>(ElasticsearchPathInfo<ClearScrollRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -447,7 +447,7 @@ internal ElasticsearchResponse<T> ClearScrollDispatch<T>(ElasticsearchPathInfo<C
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClearScrollDispatchAsync<T>(ElasticsearchPathInfo<ClearScrollQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClearScrollDispatchAsync<T>(ElasticsearchPathInfo<ClearScrollRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -462,7 +462,7 @@ internal Task<ElasticsearchResponse<T>> ClearScrollDispatchAsync<T>(Elasticsearc
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterGetSettingsDispatch<T>(ElasticsearchPathInfo<ClusterGetSettingsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterGetSettingsDispatch<T>(ElasticsearchPathInfo<ClusterGetSettingsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -475,7 +475,7 @@ internal ElasticsearchResponse<T> ClusterGetSettingsDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterGetSettingsDispatchAsync<T>(ElasticsearchPathInfo<ClusterGetSettingsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterGetSettingsDispatchAsync<T>(ElasticsearchPathInfo<ClusterGetSettingsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -488,7 +488,7 @@ internal Task<ElasticsearchResponse<T>> ClusterGetSettingsDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterHealthDispatch<T>(ElasticsearchPathInfo<ClusterHealthQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterHealthDispatch<T>(ElasticsearchPathInfo<ClusterHealthRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -504,7 +504,7 @@ internal ElasticsearchResponse<T> ClusterHealthDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterHealthDispatchAsync<T>(ElasticsearchPathInfo<ClusterHealthQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterHealthDispatchAsync<T>(ElasticsearchPathInfo<ClusterHealthRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -520,7 +520,7 @@ internal Task<ElasticsearchResponse<T>> ClusterHealthDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterPendingTasksDispatch<T>(ElasticsearchPathInfo<ClusterPendingTasksQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterPendingTasksDispatch<T>(ElasticsearchPathInfo<ClusterPendingTasksRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -533,7 +533,7 @@ internal ElasticsearchResponse<T> ClusterPendingTasksDispatch<T>(ElasticsearchPa
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterPendingTasksDispatchAsync<T>(ElasticsearchPathInfo<ClusterPendingTasksQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterPendingTasksDispatchAsync<T>(ElasticsearchPathInfo<ClusterPendingTasksRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -546,7 +546,7 @@ internal Task<ElasticsearchResponse<T>> ClusterPendingTasksDispatchAsync<T>(Elas
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterPutSettingsDispatch<T>(ElasticsearchPathInfo<ClusterPutSettingsQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterPutSettingsDispatch<T>(ElasticsearchPathInfo<ClusterPutSettingsRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -561,7 +561,7 @@ internal ElasticsearchResponse<T> ClusterPutSettingsDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterPutSettingsDispatchAsync<T>(ElasticsearchPathInfo<ClusterPutSettingsQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterPutSettingsDispatchAsync<T>(ElasticsearchPathInfo<ClusterPutSettingsRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -576,7 +576,7 @@ internal Task<ElasticsearchResponse<T>> ClusterPutSettingsDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterRerouteDispatch<T>(ElasticsearchPathInfo<ClusterRerouteQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterRerouteDispatch<T>(ElasticsearchPathInfo<ClusterRerouteRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -591,7 +591,7 @@ internal ElasticsearchResponse<T> ClusterRerouteDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterRerouteDispatchAsync<T>(ElasticsearchPathInfo<ClusterRerouteQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterRerouteDispatchAsync<T>(ElasticsearchPathInfo<ClusterRerouteRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -606,7 +606,7 @@ internal Task<ElasticsearchResponse<T>> ClusterRerouteDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterStateDispatch<T>(ElasticsearchPathInfo<ClusterStateQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterStateDispatch<T>(ElasticsearchPathInfo<ClusterStateRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -625,7 +625,7 @@ internal ElasticsearchResponse<T> ClusterStateDispatch<T>(ElasticsearchPathInfo<
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterStateDispatchAsync<T>(ElasticsearchPathInfo<ClusterStateQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterStateDispatchAsync<T>(ElasticsearchPathInfo<ClusterStateRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -644,7 +644,7 @@ internal Task<ElasticsearchResponse<T>> ClusterStateDispatchAsync<T>(Elasticsear
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterStatsDispatch<T>(ElasticsearchPathInfo<ClusterStatsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterStatsDispatch<T>(ElasticsearchPathInfo<ClusterStatsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -660,7 +660,7 @@ internal ElasticsearchResponse<T> ClusterStatsDispatch<T>(ElasticsearchPathInfo<
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterStatsDispatchAsync<T>(ElasticsearchPathInfo<ClusterStatsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterStatsDispatchAsync<T>(ElasticsearchPathInfo<ClusterStatsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -676,7 +676,7 @@ internal Task<ElasticsearchResponse<T>> ClusterStatsDispatchAsync<T>(Elasticsear
 		}
 		
 		
-		internal ElasticsearchResponse<T> CountDispatch<T>(ElasticsearchPathInfo<CountQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> CountDispatch<T>(ElasticsearchPathInfo<CountRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -707,7 +707,7 @@ internal ElasticsearchResponse<T> CountDispatch<T>(ElasticsearchPathInfo<CountQu
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CountDispatchAsync<T>(ElasticsearchPathInfo<CountQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CountDispatchAsync<T>(ElasticsearchPathInfo<CountRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -738,7 +738,7 @@ internal Task<ElasticsearchResponse<T>> CountDispatchAsync<T>(ElasticsearchPathI
 		}
 		
 		
-		internal ElasticsearchResponse<T> CountPercolateDispatch<T>(ElasticsearchPathInfo<CountPercolateQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> CountPercolateDispatch<T>(ElasticsearchPathInfo<CountPercolateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -765,7 +765,7 @@ internal ElasticsearchResponse<T> CountPercolateDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CountPercolateDispatchAsync<T>(ElasticsearchPathInfo<CountPercolateQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CountPercolateDispatchAsync<T>(ElasticsearchPathInfo<CountPercolateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -792,7 +792,7 @@ internal Task<ElasticsearchResponse<T>> CountPercolateDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> DeleteDispatch<T>(ElasticsearchPathInfo<DeleteQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> DeleteDispatch<T>(ElasticsearchPathInfo<DeleteRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -807,7 +807,7 @@ internal ElasticsearchResponse<T> DeleteDispatch<T>(ElasticsearchPathInfo<Delete
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> DeleteDispatchAsync<T>(ElasticsearchPathInfo<DeleteQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> DeleteDispatchAsync<T>(ElasticsearchPathInfo<DeleteRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -822,7 +822,7 @@ internal Task<ElasticsearchResponse<T>> DeleteDispatchAsync<T>(ElasticsearchPath
 		}
 		
 		
-		internal ElasticsearchResponse<T> DeleteByQueryDispatch<T>(ElasticsearchPathInfo<DeleteByQueryQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> DeleteByQueryDispatch<T>(ElasticsearchPathInfo<DeleteByQueryRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -840,7 +840,7 @@ internal ElasticsearchResponse<T> DeleteByQueryDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> DeleteByQueryDispatchAsync<T>(ElasticsearchPathInfo<DeleteByQueryQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> DeleteByQueryDispatchAsync<T>(ElasticsearchPathInfo<DeleteByQueryRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -858,7 +858,7 @@ internal Task<ElasticsearchResponse<T>> DeleteByQueryDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> ExistsDispatch<T>(ElasticsearchPathInfo<ExistsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ExistsDispatch<T>(ElasticsearchPathInfo<ExistsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -873,7 +873,7 @@ internal ElasticsearchResponse<T> ExistsDispatch<T>(ElasticsearchPathInfo<Exists
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ExistsDispatchAsync<T>(ElasticsearchPathInfo<ExistsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ExistsDispatchAsync<T>(ElasticsearchPathInfo<ExistsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -888,7 +888,7 @@ internal Task<ElasticsearchResponse<T>> ExistsDispatchAsync<T>(ElasticsearchPath
 		}
 		
 		
-		internal ElasticsearchResponse<T> ExplainDispatch<T>(ElasticsearchPathInfo<ExplainQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> ExplainDispatch<T>(ElasticsearchPathInfo<ExplainRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -909,7 +909,7 @@ internal ElasticsearchResponse<T> ExplainDispatch<T>(ElasticsearchPathInfo<Expla
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ExplainDispatchAsync<T>(ElasticsearchPathInfo<ExplainQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ExplainDispatchAsync<T>(ElasticsearchPathInfo<ExplainRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -930,7 +930,7 @@ internal Task<ElasticsearchResponse<T>> ExplainDispatchAsync<T>(ElasticsearchPat
 		}
 		
 		
-		internal ElasticsearchResponse<T> GetDispatch<T>(ElasticsearchPathInfo<GetQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> GetDispatch<T>(ElasticsearchPathInfo<GetRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -945,7 +945,7 @@ internal ElasticsearchResponse<T> GetDispatch<T>(ElasticsearchPathInfo<GetQueryS
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> GetDispatchAsync<T>(ElasticsearchPathInfo<GetQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> GetDispatchAsync<T>(ElasticsearchPathInfo<GetRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -960,7 +960,7 @@ internal Task<ElasticsearchResponse<T>> GetDispatchAsync<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal ElasticsearchResponse<T> GetSourceDispatch<T>(ElasticsearchPathInfo<SourceQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> GetSourceDispatch<T>(ElasticsearchPathInfo<SourceRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -975,7 +975,7 @@ internal ElasticsearchResponse<T> GetSourceDispatch<T>(ElasticsearchPathInfo<Sou
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> GetSourceDispatchAsync<T>(ElasticsearchPathInfo<SourceQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> GetSourceDispatchAsync<T>(ElasticsearchPathInfo<SourceRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -990,7 +990,7 @@ internal Task<ElasticsearchResponse<T>> GetSourceDispatchAsync<T>(ElasticsearchP
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndexDispatch<T>(ElasticsearchPathInfo<IndexQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndexDispatch<T>(ElasticsearchPathInfo<IndexRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1017,7 +1017,7 @@ internal ElasticsearchResponse<T> IndexDispatch<T>(ElasticsearchPathInfo<IndexQu
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndexDispatchAsync<T>(ElasticsearchPathInfo<IndexQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndexDispatchAsync<T>(ElasticsearchPathInfo<IndexRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1044,7 +1044,7 @@ internal Task<ElasticsearchResponse<T>> IndexDispatchAsync<T>(ElasticsearchPathI
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesAnalyzeDispatch<T>(ElasticsearchPathInfo<AnalyzeQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesAnalyzeDispatch<T>(ElasticsearchPathInfo<AnalyzeRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1069,7 +1069,7 @@ internal ElasticsearchResponse<T> IndicesAnalyzeDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesAnalyzeDispatchAsync<T>(ElasticsearchPathInfo<AnalyzeQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesAnalyzeDispatchAsync<T>(ElasticsearchPathInfo<AnalyzeRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1094,7 +1094,7 @@ internal Task<ElasticsearchResponse<T>> IndicesAnalyzeDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesClearCacheDispatch<T>(ElasticsearchPathInfo<ClearCacheQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesClearCacheDispatch<T>(ElasticsearchPathInfo<ClearCacheRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1117,7 +1117,7 @@ internal ElasticsearchResponse<T> IndicesClearCacheDispatch<T>(ElasticsearchPath
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesClearCacheDispatchAsync<T>(ElasticsearchPathInfo<ClearCacheQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesClearCacheDispatchAsync<T>(ElasticsearchPathInfo<ClearCacheRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1140,7 +1140,7 @@ internal Task<ElasticsearchResponse<T>> IndicesClearCacheDispatchAsync<T>(Elasti
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesCloseDispatch<T>(ElasticsearchPathInfo<CloseIndexQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesCloseDispatch<T>(ElasticsearchPathInfo<CloseIndexRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1155,7 +1155,7 @@ internal ElasticsearchResponse<T> IndicesCloseDispatch<T>(ElasticsearchPathInfo<
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesCloseDispatchAsync<T>(ElasticsearchPathInfo<CloseIndexQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesCloseDispatchAsync<T>(ElasticsearchPathInfo<CloseIndexRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1170,7 +1170,7 @@ internal Task<ElasticsearchResponse<T>> IndicesCloseDispatchAsync<T>(Elasticsear
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesCreateDispatch<T>(ElasticsearchPathInfo<CreateIndexQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesCreateDispatch<T>(ElasticsearchPathInfo<CreateIndexRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1191,7 +1191,7 @@ internal ElasticsearchResponse<T> IndicesCreateDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesCreateDispatchAsync<T>(ElasticsearchPathInfo<CreateIndexQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesCreateDispatchAsync<T>(ElasticsearchPathInfo<CreateIndexRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1212,7 +1212,7 @@ internal Task<ElasticsearchResponse<T>> IndicesCreateDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteDispatch<T>(ElasticsearchPathInfo<DeleteIndexQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteDispatch<T>(ElasticsearchPathInfo<DeleteIndexRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1227,7 +1227,7 @@ internal ElasticsearchResponse<T> IndicesDeleteDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteDispatchAsync<T>(ElasticsearchPathInfo<DeleteIndexQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteDispatchAsync<T>(ElasticsearchPathInfo<DeleteIndexRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1242,7 +1242,7 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteAliasDispatch<T>(ElasticsearchPathInfo<IndicesDeleteAliasQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteAliasDispatch<T>(ElasticsearchPathInfo<IndicesDeleteAliasRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1257,7 +1257,7 @@ internal ElasticsearchResponse<T> IndicesDeleteAliasDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesDeleteAliasQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesDeleteAliasRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1272,7 +1272,7 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteAliasDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteMappingDispatch<T>(ElasticsearchPathInfo<DeleteMappingQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteMappingDispatch<T>(ElasticsearchPathInfo<DeleteMappingRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1287,7 +1287,7 @@ internal ElasticsearchResponse<T> IndicesDeleteMappingDispatch<T>(ElasticsearchP
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteMappingDispatchAsync<T>(ElasticsearchPathInfo<DeleteMappingQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteMappingDispatchAsync<T>(ElasticsearchPathInfo<DeleteMappingRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1302,7 +1302,7 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteMappingDispatchAsync<T>(Ela
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteTemplateDispatch<T>(ElasticsearchPathInfo<DeleteTemplateQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteTemplateDispatch<T>(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1317,7 +1317,7 @@ internal ElasticsearchResponse<T> IndicesDeleteTemplateDispatch<T>(Elasticsearch
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteTemplateDispatchAsync<T>(ElasticsearchPathInfo<DeleteTemplateQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteTemplateDispatchAsync<T>(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1332,7 +1332,7 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteTemplateDispatchAsync<T>(El
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteWarmerDispatch<T>(ElasticsearchPathInfo<DeleteWarmerQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteWarmerDispatch<T>(ElasticsearchPathInfo<DeleteWarmerRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1347,7 +1347,7 @@ internal ElasticsearchResponse<T> IndicesDeleteWarmerDispatch<T>(ElasticsearchPa
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteWarmerDispatchAsync<T>(ElasticsearchPathInfo<DeleteWarmerQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteWarmerDispatchAsync<T>(ElasticsearchPathInfo<DeleteWarmerRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1362,7 +1362,7 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteWarmerDispatchAsync<T>(Elas
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesExistsDispatch<T>(ElasticsearchPathInfo<IndexExistsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesExistsDispatch<T>(ElasticsearchPathInfo<IndexExistsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1377,7 +1377,7 @@ internal ElasticsearchResponse<T> IndicesExistsDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesExistsDispatchAsync<T>(ElasticsearchPathInfo<IndexExistsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesExistsDispatchAsync<T>(ElasticsearchPathInfo<IndexExistsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1392,7 +1392,7 @@ internal Task<ElasticsearchResponse<T>> IndicesExistsDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesExistsAliasDispatch<T>(ElasticsearchPathInfo<IndicesExistsAliasQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesExistsAliasDispatch<T>(ElasticsearchPathInfo<IndicesExistsAliasRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1413,7 +1413,7 @@ internal ElasticsearchResponse<T> IndicesExistsAliasDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesExistsAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsAliasQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesExistsAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsAliasRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1434,7 +1434,7 @@ internal Task<ElasticsearchResponse<T>> IndicesExistsAliasDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesExistsTemplateDispatch<T>(ElasticsearchPathInfo<IndicesExistsTemplateQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesExistsTemplateDispatch<T>(ElasticsearchPathInfo<IndicesExistsTemplateRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1449,7 +1449,7 @@ internal ElasticsearchResponse<T> IndicesExistsTemplateDispatch<T>(Elasticsearch
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesExistsTemplateDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsTemplateQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesExistsTemplateDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsTemplateRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1464,7 +1464,7 @@ internal Task<ElasticsearchResponse<T>> IndicesExistsTemplateDispatchAsync<T>(El
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesExistsTypeDispatch<T>(ElasticsearchPathInfo<IndicesExistsTypeQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesExistsTypeDispatch<T>(ElasticsearchPathInfo<IndicesExistsTypeRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1479,7 +1479,7 @@ internal ElasticsearchResponse<T> IndicesExistsTypeDispatch<T>(ElasticsearchPath
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesExistsTypeDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsTypeQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesExistsTypeDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsTypeRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1494,7 +1494,7 @@ internal Task<ElasticsearchResponse<T>> IndicesExistsTypeDispatchAsync<T>(Elasti
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesFlushDispatch<T>(ElasticsearchPathInfo<FlushQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesFlushDispatch<T>(ElasticsearchPathInfo<FlushRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1517,7 +1517,7 @@ internal ElasticsearchResponse<T> IndicesFlushDispatch<T>(ElasticsearchPathInfo<
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesFlushDispatchAsync<T>(ElasticsearchPathInfo<FlushQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesFlushDispatchAsync<T>(ElasticsearchPathInfo<FlushRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1540,7 +1540,7 @@ internal Task<ElasticsearchResponse<T>> IndicesFlushDispatchAsync<T>(Elasticsear
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetAliasDispatch<T>(ElasticsearchPathInfo<GetAliasesQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetAliasDispatch<T>(ElasticsearchPathInfo<GetAliasesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1562,7 +1562,7 @@ internal ElasticsearchResponse<T> IndicesGetAliasDispatch<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetAliasDispatchAsync<T>(ElasticsearchPathInfo<GetAliasesQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetAliasDispatchAsync<T>(ElasticsearchPathInfo<GetAliasesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1584,7 +1584,7 @@ internal Task<ElasticsearchResponse<T>> IndicesGetAliasDispatchAsync<T>(Elastics
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetAliasesDispatch<T>(ElasticsearchPathInfo<IndicesGetAliasesQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetAliasesDispatch<T>(ElasticsearchPathInfo<IndicesGetAliasesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1606,7 +1606,7 @@ internal ElasticsearchResponse<T> IndicesGetAliasesDispatch<T>(ElasticsearchPath
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetAliasesDispatchAsync<T>(ElasticsearchPathInfo<IndicesGetAliasesQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetAliasesDispatchAsync<T>(ElasticsearchPathInfo<IndicesGetAliasesRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1628,7 +1628,7 @@ internal Task<ElasticsearchResponse<T>> IndicesGetAliasesDispatchAsync<T>(Elasti
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetFieldMappingDispatch<T>(ElasticsearchPathInfo<IndicesGetFieldMappingQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetFieldMappingDispatch<T>(ElasticsearchPathInfo<IndicesGetFieldMappingRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1652,7 +1652,7 @@ internal ElasticsearchResponse<T> IndicesGetFieldMappingDispatch<T>(Elasticsearc
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetFieldMappingDispatchAsync<T>(ElasticsearchPathInfo<IndicesGetFieldMappingQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetFieldMappingDispatchAsync<T>(ElasticsearchPathInfo<IndicesGetFieldMappingRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1676,7 +1676,7 @@ internal Task<ElasticsearchResponse<T>> IndicesGetFieldMappingDispatchAsync<T>(E
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetMappingDispatch<T>(ElasticsearchPathInfo<GetMappingQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetMappingDispatch<T>(ElasticsearchPathInfo<GetMappingRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1698,7 +1698,7 @@ internal ElasticsearchResponse<T> IndicesGetMappingDispatch<T>(ElasticsearchPath
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetMappingDispatchAsync<T>(ElasticsearchPathInfo<GetMappingQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetMappingDispatchAsync<T>(ElasticsearchPathInfo<GetMappingRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1720,7 +1720,7 @@ internal Task<ElasticsearchResponse<T>> IndicesGetMappingDispatchAsync<T>(Elasti
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetSettingsDispatch<T>(ElasticsearchPathInfo<GetIndexSettingsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetSettingsDispatch<T>(ElasticsearchPathInfo<GetIndexSettingsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1742,7 +1742,7 @@ internal ElasticsearchResponse<T> IndicesGetSettingsDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetSettingsDispatchAsync<T>(ElasticsearchPathInfo<GetIndexSettingsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetSettingsDispatchAsync<T>(ElasticsearchPathInfo<GetIndexSettingsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1764,7 +1764,7 @@ internal Task<ElasticsearchResponse<T>> IndicesGetSettingsDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetTemplateDispatch<T>(ElasticsearchPathInfo<GetTemplateQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetTemplateDispatch<T>(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1780,7 +1780,7 @@ internal ElasticsearchResponse<T> IndicesGetTemplateDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetTemplateDispatchAsync<T>(ElasticsearchPathInfo<GetTemplateQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetTemplateDispatchAsync<T>(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1796,7 +1796,7 @@ internal Task<ElasticsearchResponse<T>> IndicesGetTemplateDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetWarmerDispatch<T>(ElasticsearchPathInfo<GetWarmerQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetWarmerDispatch<T>(ElasticsearchPathInfo<GetWarmerRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1821,7 +1821,7 @@ internal ElasticsearchResponse<T> IndicesGetWarmerDispatch<T>(ElasticsearchPathI
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetWarmerDispatchAsync<T>(ElasticsearchPathInfo<GetWarmerQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetWarmerDispatchAsync<T>(ElasticsearchPathInfo<GetWarmerRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1846,7 +1846,7 @@ internal Task<ElasticsearchResponse<T>> IndicesGetWarmerDispatchAsync<T>(Elastic
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesOpenDispatch<T>(ElasticsearchPathInfo<OpenIndexQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesOpenDispatch<T>(ElasticsearchPathInfo<OpenIndexRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1861,7 +1861,7 @@ internal ElasticsearchResponse<T> IndicesOpenDispatch<T>(ElasticsearchPathInfo<O
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesOpenDispatchAsync<T>(ElasticsearchPathInfo<OpenIndexQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesOpenDispatchAsync<T>(ElasticsearchPathInfo<OpenIndexRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1876,7 +1876,7 @@ internal Task<ElasticsearchResponse<T>> IndicesOpenDispatchAsync<T>(Elasticsearc
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesOptimizeDispatch<T>(ElasticsearchPathInfo<OptimizeQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesOptimizeDispatch<T>(ElasticsearchPathInfo<OptimizeRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1899,7 +1899,7 @@ internal ElasticsearchResponse<T> IndicesOptimizeDispatch<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesOptimizeDispatchAsync<T>(ElasticsearchPathInfo<OptimizeQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesOptimizeDispatchAsync<T>(ElasticsearchPathInfo<OptimizeRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1922,7 +1922,7 @@ internal Task<ElasticsearchResponse<T>> IndicesOptimizeDispatchAsync<T>(Elastics
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutAliasDispatch<T>(ElasticsearchPathInfo<IndicesPutAliasQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutAliasDispatch<T>(ElasticsearchPathInfo<IndicesPutAliasRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1949,7 +1949,7 @@ internal ElasticsearchResponse<T> IndicesPutAliasDispatch<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesPutAliasQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesPutAliasRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -1976,7 +1976,7 @@ internal Task<ElasticsearchResponse<T>> IndicesPutAliasDispatchAsync<T>(Elastics
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutMappingDispatch<T>(ElasticsearchPathInfo<PutMappingQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutMappingDispatch<T>(ElasticsearchPathInfo<PutMappingRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2003,7 +2003,7 @@ internal ElasticsearchResponse<T> IndicesPutMappingDispatch<T>(ElasticsearchPath
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutMappingDispatchAsync<T>(ElasticsearchPathInfo<PutMappingQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutMappingDispatchAsync<T>(ElasticsearchPathInfo<PutMappingRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2030,7 +2030,7 @@ internal Task<ElasticsearchResponse<T>> IndicesPutMappingDispatchAsync<T>(Elasti
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutSettingsDispatch<T>(ElasticsearchPathInfo<UpdateSettingsQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutSettingsDispatch<T>(ElasticsearchPathInfo<UpdateSettingsRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2048,7 +2048,7 @@ internal ElasticsearchResponse<T> IndicesPutSettingsDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutSettingsDispatchAsync<T>(ElasticsearchPathInfo<UpdateSettingsQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutSettingsDispatchAsync<T>(ElasticsearchPathInfo<UpdateSettingsRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2066,7 +2066,7 @@ internal Task<ElasticsearchResponse<T>> IndicesPutSettingsDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutTemplateDispatch<T>(ElasticsearchPathInfo<PutTemplateQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutTemplateDispatch<T>(ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2087,7 +2087,7 @@ internal ElasticsearchResponse<T> IndicesPutTemplateDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutTemplateDispatchAsync<T>(ElasticsearchPathInfo<PutTemplateQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutTemplateDispatchAsync<T>(ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2108,7 +2108,7 @@ internal Task<ElasticsearchResponse<T>> IndicesPutTemplateDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutWarmerDispatch<T>(ElasticsearchPathInfo<PutWarmerQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutWarmerDispatch<T>(ElasticsearchPathInfo<PutWarmerRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2141,7 +2141,7 @@ internal ElasticsearchResponse<T> IndicesPutWarmerDispatch<T>(ElasticsearchPathI
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutWarmerDispatchAsync<T>(ElasticsearchPathInfo<PutWarmerQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutWarmerDispatchAsync<T>(ElasticsearchPathInfo<PutWarmerRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2174,7 +2174,7 @@ internal Task<ElasticsearchResponse<T>> IndicesPutWarmerDispatchAsync<T>(Elastic
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesRefreshDispatch<T>(ElasticsearchPathInfo<RefreshQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesRefreshDispatch<T>(ElasticsearchPathInfo<RefreshRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2197,7 +2197,7 @@ internal ElasticsearchResponse<T> IndicesRefreshDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesRefreshDispatchAsync<T>(ElasticsearchPathInfo<RefreshQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesRefreshDispatchAsync<T>(ElasticsearchPathInfo<RefreshRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2220,7 +2220,7 @@ internal Task<ElasticsearchResponse<T>> IndicesRefreshDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesSegmentsDispatch<T>(ElasticsearchPathInfo<SegmentsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesSegmentsDispatch<T>(ElasticsearchPathInfo<SegmentsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2236,7 +2236,7 @@ internal ElasticsearchResponse<T> IndicesSegmentsDispatch<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesSegmentsDispatchAsync<T>(ElasticsearchPathInfo<SegmentsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesSegmentsDispatchAsync<T>(ElasticsearchPathInfo<SegmentsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2252,7 +2252,7 @@ internal Task<ElasticsearchResponse<T>> IndicesSegmentsDispatchAsync<T>(Elastics
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesSnapshotIndexDispatch<T>(ElasticsearchPathInfo<SnapshotQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesSnapshotIndexDispatch<T>(ElasticsearchPathInfo<SnapshotRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2268,7 +2268,7 @@ internal ElasticsearchResponse<T> IndicesSnapshotIndexDispatch<T>(ElasticsearchP
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesSnapshotIndexDispatchAsync<T>(ElasticsearchPathInfo<SnapshotQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesSnapshotIndexDispatchAsync<T>(ElasticsearchPathInfo<SnapshotRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2284,7 +2284,7 @@ internal Task<ElasticsearchResponse<T>> IndicesSnapshotIndexDispatchAsync<T>(Ela
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesStatsDispatch<T>(ElasticsearchPathInfo<IndicesStatsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesStatsDispatch<T>(ElasticsearchPathInfo<IndicesStatsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2306,7 +2306,7 @@ internal ElasticsearchResponse<T> IndicesStatsDispatch<T>(ElasticsearchPathInfo<
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesStatsDispatchAsync<T>(ElasticsearchPathInfo<IndicesStatsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesStatsDispatchAsync<T>(ElasticsearchPathInfo<IndicesStatsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2328,7 +2328,7 @@ internal Task<ElasticsearchResponse<T>> IndicesStatsDispatchAsync<T>(Elasticsear
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesStatusDispatch<T>(ElasticsearchPathInfo<IndicesStatusQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesStatusDispatch<T>(ElasticsearchPathInfo<IndicesStatusRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2344,7 +2344,7 @@ internal ElasticsearchResponse<T> IndicesStatusDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesStatusDispatchAsync<T>(ElasticsearchPathInfo<IndicesStatusQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesStatusDispatchAsync<T>(ElasticsearchPathInfo<IndicesStatusRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2360,7 +2360,7 @@ internal Task<ElasticsearchResponse<T>> IndicesStatusDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesUpdateAliasesDispatch<T>(ElasticsearchPathInfo<AliasQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesUpdateAliasesDispatch<T>(ElasticsearchPathInfo<AliasRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2375,7 +2375,7 @@ internal ElasticsearchResponse<T> IndicesUpdateAliasesDispatch<T>(ElasticsearchP
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesUpdateAliasesDispatchAsync<T>(ElasticsearchPathInfo<AliasQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesUpdateAliasesDispatchAsync<T>(ElasticsearchPathInfo<AliasRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2390,7 +2390,7 @@ internal Task<ElasticsearchResponse<T>> IndicesUpdateAliasesDispatchAsync<T>(Ela
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesValidateQueryDispatch<T>(ElasticsearchPathInfo<ValidateQueryQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesValidateQueryDispatch<T>(ElasticsearchPathInfo<ValidateQueryRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2421,7 +2421,7 @@ internal ElasticsearchResponse<T> IndicesValidateQueryDispatch<T>(ElasticsearchP
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesValidateQueryDispatchAsync<T>(ElasticsearchPathInfo<ValidateQueryQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesValidateQueryDispatchAsync<T>(ElasticsearchPathInfo<ValidateQueryRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2452,7 +2452,7 @@ internal Task<ElasticsearchResponse<T>> IndicesValidateQueryDispatchAsync<T>(Ela
 		}
 		
 		
-		internal ElasticsearchResponse<T> InfoDispatch<T>(ElasticsearchPathInfo<InfoQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> InfoDispatch<T>(ElasticsearchPathInfo<InfoRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2465,7 +2465,7 @@ internal ElasticsearchResponse<T> InfoDispatch<T>(ElasticsearchPathInfo<InfoQuer
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> InfoDispatchAsync<T>(ElasticsearchPathInfo<InfoQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> InfoDispatchAsync<T>(ElasticsearchPathInfo<InfoRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2478,7 +2478,7 @@ internal Task<ElasticsearchResponse<T>> InfoDispatchAsync<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal ElasticsearchResponse<T> MgetDispatch<T>(ElasticsearchPathInfo<MultiGetQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MgetDispatch<T>(ElasticsearchPathInfo<MultiGetRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2509,7 +2509,7 @@ internal ElasticsearchResponse<T> MgetDispatch<T>(ElasticsearchPathInfo<MultiGet
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MgetDispatchAsync<T>(ElasticsearchPathInfo<MultiGetQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MgetDispatchAsync<T>(ElasticsearchPathInfo<MultiGetRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2540,7 +2540,7 @@ internal Task<ElasticsearchResponse<T>> MgetDispatchAsync<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal ElasticsearchResponse<T> MltDispatch<T>(ElasticsearchPathInfo<MoreLikeThisQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MltDispatch<T>(ElasticsearchPathInfo<MoreLikeThisRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2561,7 +2561,7 @@ internal ElasticsearchResponse<T> MltDispatch<T>(ElasticsearchPathInfo<MoreLikeT
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MltDispatchAsync<T>(ElasticsearchPathInfo<MoreLikeThisQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MltDispatchAsync<T>(ElasticsearchPathInfo<MoreLikeThisRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2582,7 +2582,7 @@ internal Task<ElasticsearchResponse<T>> MltDispatchAsync<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal ElasticsearchResponse<T> MpercolateDispatch<T>(ElasticsearchPathInfo<MpercolateQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MpercolateDispatch<T>(ElasticsearchPathInfo<MpercolateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2613,7 +2613,7 @@ internal ElasticsearchResponse<T> MpercolateDispatch<T>(ElasticsearchPathInfo<Mp
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MpercolateDispatchAsync<T>(ElasticsearchPathInfo<MpercolateQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MpercolateDispatchAsync<T>(ElasticsearchPathInfo<MpercolateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2644,7 +2644,7 @@ internal Task<ElasticsearchResponse<T>> MpercolateDispatchAsync<T>(Elasticsearch
 		}
 		
 		
-		internal ElasticsearchResponse<T> MsearchDispatch<T>(ElasticsearchPathInfo<MultiSearchQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MsearchDispatch<T>(ElasticsearchPathInfo<MultiSearchRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2675,7 +2675,7 @@ internal ElasticsearchResponse<T> MsearchDispatch<T>(ElasticsearchPathInfo<Multi
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MsearchDispatchAsync<T>(ElasticsearchPathInfo<MultiSearchQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MsearchDispatchAsync<T>(ElasticsearchPathInfo<MultiSearchRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2706,7 +2706,7 @@ internal Task<ElasticsearchResponse<T>> MsearchDispatchAsync<T>(ElasticsearchPat
 		}
 		
 		
-		internal ElasticsearchResponse<T> MtermvectorsDispatch<T>(ElasticsearchPathInfo<MtermvectorsQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MtermvectorsDispatch<T>(ElasticsearchPathInfo<MtermvectorsRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2737,7 +2737,7 @@ internal ElasticsearchResponse<T> MtermvectorsDispatch<T>(ElasticsearchPathInfo<
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MtermvectorsDispatchAsync<T>(ElasticsearchPathInfo<MtermvectorsQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MtermvectorsDispatchAsync<T>(ElasticsearchPathInfo<MtermvectorsRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2768,7 +2768,7 @@ internal Task<ElasticsearchResponse<T>> MtermvectorsDispatchAsync<T>(Elasticsear
 		}
 		
 		
-		internal ElasticsearchResponse<T> NodesHotThreadsDispatch<T>(ElasticsearchPathInfo<NodesHotThreadsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> NodesHotThreadsDispatch<T>(ElasticsearchPathInfo<NodesHotThreadsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2784,7 +2784,7 @@ internal ElasticsearchResponse<T> NodesHotThreadsDispatch<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> NodesHotThreadsDispatchAsync<T>(ElasticsearchPathInfo<NodesHotThreadsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> NodesHotThreadsDispatchAsync<T>(ElasticsearchPathInfo<NodesHotThreadsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2800,7 +2800,7 @@ internal Task<ElasticsearchResponse<T>> NodesHotThreadsDispatchAsync<T>(Elastics
 		}
 		
 		
-		internal ElasticsearchResponse<T> NodesInfoDispatch<T>(ElasticsearchPathInfo<NodesInfoQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> NodesInfoDispatch<T>(ElasticsearchPathInfo<NodesInfoRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2822,7 +2822,7 @@ internal ElasticsearchResponse<T> NodesInfoDispatch<T>(ElasticsearchPathInfo<Nod
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> NodesInfoDispatchAsync<T>(ElasticsearchPathInfo<NodesInfoQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> NodesInfoDispatchAsync<T>(ElasticsearchPathInfo<NodesInfoRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2844,7 +2844,7 @@ internal Task<ElasticsearchResponse<T>> NodesInfoDispatchAsync<T>(ElasticsearchP
 		}
 		
 		
-		internal ElasticsearchResponse<T> NodesShutdownDispatch<T>(ElasticsearchPathInfo<NodesShutdownQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> NodesShutdownDispatch<T>(ElasticsearchPathInfo<NodesShutdownRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2860,7 +2860,7 @@ internal ElasticsearchResponse<T> NodesShutdownDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> NodesShutdownDispatchAsync<T>(ElasticsearchPathInfo<NodesShutdownQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> NodesShutdownDispatchAsync<T>(ElasticsearchPathInfo<NodesShutdownRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2876,7 +2876,7 @@ internal Task<ElasticsearchResponse<T>> NodesShutdownDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> NodesStatsDispatch<T>(ElasticsearchPathInfo<NodesStatsQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> NodesStatsDispatch<T>(ElasticsearchPathInfo<NodesStatsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2904,7 +2904,7 @@ internal ElasticsearchResponse<T> NodesStatsDispatch<T>(ElasticsearchPathInfo<No
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> NodesStatsDispatchAsync<T>(ElasticsearchPathInfo<NodesStatsQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> NodesStatsDispatchAsync<T>(ElasticsearchPathInfo<NodesStatsRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2932,7 +2932,7 @@ internal Task<ElasticsearchResponse<T>> NodesStatsDispatchAsync<T>(Elasticsearch
 		}
 		
 		
-		internal ElasticsearchResponse<T> PercolateDispatch<T>(ElasticsearchPathInfo<PercolateQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> PercolateDispatch<T>(ElasticsearchPathInfo<PercolateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2959,7 +2959,7 @@ internal ElasticsearchResponse<T> PercolateDispatch<T>(ElasticsearchPathInfo<Per
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> PercolateDispatchAsync<T>(ElasticsearchPathInfo<PercolateQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> PercolateDispatchAsync<T>(ElasticsearchPathInfo<PercolateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2986,7 +2986,7 @@ internal Task<ElasticsearchResponse<T>> PercolateDispatchAsync<T>(ElasticsearchP
 		}
 		
 		
-		internal ElasticsearchResponse<T> PingDispatch<T>(ElasticsearchPathInfo<PingQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> PingDispatch<T>(ElasticsearchPathInfo<PingRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -2999,7 +2999,7 @@ internal ElasticsearchResponse<T> PingDispatch<T>(ElasticsearchPathInfo<PingQuer
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> PingDispatchAsync<T>(ElasticsearchPathInfo<PingQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> PingDispatchAsync<T>(ElasticsearchPathInfo<PingRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3012,7 +3012,7 @@ internal Task<ElasticsearchResponse<T>> PingDispatchAsync<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal ElasticsearchResponse<T> ScrollDispatch<T>(ElasticsearchPathInfo<ScrollQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> ScrollDispatch<T>(ElasticsearchPathInfo<ScrollRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3037,7 +3037,7 @@ internal ElasticsearchResponse<T> ScrollDispatch<T>(ElasticsearchPathInfo<Scroll
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ScrollDispatchAsync<T>(ElasticsearchPathInfo<ScrollQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ScrollDispatchAsync<T>(ElasticsearchPathInfo<ScrollRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3062,7 +3062,7 @@ internal Task<ElasticsearchResponse<T>> ScrollDispatchAsync<T>(ElasticsearchPath
 		}
 		
 		
-		internal ElasticsearchResponse<T> SearchDispatch<T>(ElasticsearchPathInfo<SearchQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SearchDispatch<T>(ElasticsearchPathInfo<SearchRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3093,7 +3093,7 @@ internal ElasticsearchResponse<T> SearchDispatch<T>(ElasticsearchPathInfo<Search
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SearchDispatchAsync<T>(ElasticsearchPathInfo<SearchQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SearchDispatchAsync<T>(ElasticsearchPathInfo<SearchRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3124,7 +3124,7 @@ internal Task<ElasticsearchResponse<T>> SearchDispatchAsync<T>(ElasticsearchPath
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotCreateDispatch<T>(ElasticsearchPathInfo<SnapshotCreateQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotCreateDispatch<T>(ElasticsearchPathInfo<SnapshotCreateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3145,7 +3145,7 @@ internal ElasticsearchResponse<T> SnapshotCreateDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotCreateDispatchAsync<T>(ElasticsearchPathInfo<SnapshotCreateQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotCreateDispatchAsync<T>(ElasticsearchPathInfo<SnapshotCreateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3166,7 +3166,7 @@ internal Task<ElasticsearchResponse<T>> SnapshotCreateDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotCreateRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotCreateRepositoryQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotCreateRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotCreateRepositoryRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3187,7 +3187,7 @@ internal ElasticsearchResponse<T> SnapshotCreateRepositoryDispatch<T>(Elasticsea
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotCreateRepositoryQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotCreateRepositoryRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3208,7 +3208,7 @@ internal Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryDispatchAsync<T>
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotDeleteDispatch<T>(ElasticsearchPathInfo<SnapshotDeleteQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotDeleteDispatch<T>(ElasticsearchPathInfo<SnapshotDeleteRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3223,7 +3223,7 @@ internal ElasticsearchResponse<T> SnapshotDeleteDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotDeleteDispatchAsync<T>(ElasticsearchPathInfo<SnapshotDeleteQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotDeleteDispatchAsync<T>(ElasticsearchPathInfo<SnapshotDeleteRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3238,7 +3238,7 @@ internal Task<ElasticsearchResponse<T>> SnapshotDeleteDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotDeleteRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotDeleteRepositoryQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotDeleteRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotDeleteRepositoryRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3253,7 +3253,7 @@ internal ElasticsearchResponse<T> SnapshotDeleteRepositoryDispatch<T>(Elasticsea
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotDeleteRepositoryQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotDeleteRepositoryRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3268,7 +3268,7 @@ internal Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryDispatchAsync<T>
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotGetDispatch<T>(ElasticsearchPathInfo<SnapshotGetQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotGetDispatch<T>(ElasticsearchPathInfo<SnapshotGetRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3283,7 +3283,7 @@ internal ElasticsearchResponse<T> SnapshotGetDispatch<T>(ElasticsearchPathInfo<S
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotGetDispatchAsync<T>(ElasticsearchPathInfo<SnapshotGetQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotGetDispatchAsync<T>(ElasticsearchPathInfo<SnapshotGetRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3298,7 +3298,7 @@ internal Task<ElasticsearchResponse<T>> SnapshotGetDispatchAsync<T>(Elasticsearc
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotGetRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotGetRepositoryQueryString> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotGetRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotGetRepositoryRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3314,7 +3314,7 @@ internal ElasticsearchResponse<T> SnapshotGetRepositoryDispatch<T>(Elasticsearch
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotGetRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotGetRepositoryQueryString> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotGetRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotGetRepositoryRequestParameters> pathInfo , object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3330,7 +3330,7 @@ internal Task<ElasticsearchResponse<T>> SnapshotGetRepositoryDispatchAsync<T>(El
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotRestoreDispatch<T>(ElasticsearchPathInfo<SnapshotRestoreQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotRestoreDispatch<T>(ElasticsearchPathInfo<SnapshotRestoreRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3345,7 +3345,7 @@ internal ElasticsearchResponse<T> SnapshotRestoreDispatch<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotRestoreDispatchAsync<T>(ElasticsearchPathInfo<SnapshotRestoreQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotRestoreDispatchAsync<T>(ElasticsearchPathInfo<SnapshotRestoreRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3360,7 +3360,7 @@ internal Task<ElasticsearchResponse<T>> SnapshotRestoreDispatchAsync<T>(Elastics
 		}
 		
 		
-		internal ElasticsearchResponse<T> SuggestDispatch<T>(ElasticsearchPathInfo<SuggestQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SuggestDispatch<T>(ElasticsearchPathInfo<SuggestRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3385,7 +3385,7 @@ internal ElasticsearchResponse<T> SuggestDispatch<T>(ElasticsearchPathInfo<Sugge
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SuggestDispatchAsync<T>(ElasticsearchPathInfo<SuggestQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SuggestDispatchAsync<T>(ElasticsearchPathInfo<SuggestRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3410,7 +3410,7 @@ internal Task<ElasticsearchResponse<T>> SuggestDispatchAsync<T>(ElasticsearchPat
 		}
 		
 		
-		internal ElasticsearchResponse<T> TermvectorDispatch<T>(ElasticsearchPathInfo<TermvectorQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> TermvectorDispatch<T>(ElasticsearchPathInfo<TermvectorRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3431,7 +3431,7 @@ internal ElasticsearchResponse<T> TermvectorDispatch<T>(ElasticsearchPathInfo<Te
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> TermvectorDispatchAsync<T>(ElasticsearchPathInfo<TermvectorQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> TermvectorDispatchAsync<T>(ElasticsearchPathInfo<TermvectorRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3452,7 +3452,7 @@ internal Task<ElasticsearchResponse<T>> TermvectorDispatchAsync<T>(Elasticsearch
 		}
 		
 		
-		internal ElasticsearchResponse<T> UpdateDispatch<T>(ElasticsearchPathInfo<UpdateQueryString> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> UpdateDispatch<T>(ElasticsearchPathInfo<UpdateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -3467,7 +3467,7 @@ internal ElasticsearchResponse<T> UpdateDispatch<T>(ElasticsearchPathInfo<Update
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> UpdateDispatchAsync<T>(ElasticsearchPathInfo<UpdateQueryString> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> UpdateDispatchAsync<T>(ElasticsearchPathInfo<UpdateRequestParameters> pathInfo , object body, object deserializationState = null)
 		{
 			switch(pathInfo.HttpMethod)
 			{

From 99d72f74cfa172f3d4779688fac154e1d70a7cd3 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Mon, 31 Mar 2014 14:36:26 +0200
Subject: [PATCH 06/20] refactored much of the nullable parameters on transport
 to separate state objects, can now control request specific parameters beyond
 just querystring

---
 .../Domain/ApiEndpoint.cs                     |     6 +-
 .../ElasticsearchClient.Generated.cshtml      |    27 +-
 .../IElasticsearchClient.Generated.cshtml     |     9 +-
 .../Views/RawDispatch.Generated.cshtml        |     8 +-
 .../Connection/ITransport.cs                  |     6 +-
 src/Elasticsearch.Net/Connection/Transport.cs |    30 +-
 .../Domain/FluentRequestParameters.cs         |    39 +-
 .../ElasticsearchClient.Generated.cs          | 19152 +++++++++-------
 src/Elasticsearch.Net/ElasticsearchClient.cs  |    23 +-
 .../IElasticsearchClient.Generated.cs         |  7296 ++++--
 src/Nest/DSL/AliasDescriptor.cs               |     2 +-
 src/Nest/DSL/CreateIndexDescriptor.cs         |     2 +-
 src/Nest/DSL/InfoDescriptor.cs                |     2 +-
 src/Nest/DSL/Paths/DocumentPathDescriptor.cs  |     2 +-
 .../DSL/Paths/FixedIndexTypePathDescriptor.cs |     2 +-
 src/Nest/DSL/Paths/IndexNamePathDescriptor.cs |     2 +-
 .../DSL/Paths/IndexOptionalPathDescriptor.cs  |     2 +-
 src/Nest/DSL/Paths/IndexPathDescriptor.cs     |     2 +-
 src/Nest/DSL/Paths/IndexTypePathDescriptor.cs |     2 +-
 .../DSL/Paths/IndexTypePathTypedDescriptor.cs |     2 +-
 ...ndicesOptionalExplicitAllPathDescriptor.cs |     2 +-
 .../Paths/IndicesOptionalPathDescriptor.cs    |     2 +-
 .../IndicesOptionalTypesNamePathDecriptor.cs  |     2 +-
 .../DSL/Paths/IndicesTypePathDescriptor.cs    |     2 +-
 src/Nest/DSL/Paths/NamePathDescriptor.cs      |     2 +-
 .../DSL/Paths/NodeIdOptionalDescriptor.cs     |     2 +-
 src/Nest/DSL/Paths/QueryPathDescriptor.cs     |     2 +-
 src/Nest/DSL/ScrollDescriptor.cs              |     2 +-
 src/Nest/DSL/SearchDescriptor.cs              |     2 +-
 src/Nest/DSL/UpdateDescriptor.cs              |     2 +-
 src/Nest/DSL/UpdateSettingsDescriptor.cs      |     2 +-
 src/Nest/DSL/ValidateQueryDescriptor.cs       |     2 +-
 .../Domain/Paths/ElasticSearchPathInfo.cs     |    10 +-
 src/Nest/ElasticClient-Aliases.cs             |     6 +-
 src/Nest/ElasticClient-IndexExists.cs         |    16 +-
 src/Nest/ElasticClient-MappingGet.cs          |     6 +-
 src/Nest/ElasticClient-MultiGet.cs            |     4 +-
 src/Nest/ElasticClient-MultiSearch.cs         |     4 +-
 src/Nest/ElasticClient-Search.cs              |    17 +-
 src/Nest/ElasticClient-Template.cs            |     8 +-
 src/Nest/ElasticClient-Warmers.cs             |     6 +-
 src/Nest/RawDispatch.generated.cs             |  1268 +-
 42 files changed, 16742 insertions(+), 11243 deletions(-)

diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs b/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs
index cc5914576a1..336d9722c3a 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs
@@ -13,7 +13,7 @@ public IEnumerable<string> MethodArguments
 			{
 				var methodArgs = CsharpMethod.Parts
 					.Select(p => (p.Name != "body") ? "pathInfo." + p.Name.ToPascalCase() : "body")
-					.Concat(new[] {"u => pathInfo.QueryString"});
+					.Concat(new[] {"u => pathInfo.RequestParameters"});
 				return methodArgs;
 			}
 		} 
@@ -170,8 +170,7 @@ public IEnumerable<CsharpMethod> CsharpMethods
 
 						args = args.Concat(new[] 
 						{ 
-							"Func<"+apiMethod.QueryStringParamName+", " + apiMethod.QueryStringParamName + "> queryString = null",
-							"object deserializationState = null"
+							"Func<"+apiMethod.QueryStringParamName+", " + apiMethod.QueryStringParamName + "> requestParameters = null"
 						}).ToList();
 						apiMethod.Arguments = string.Join(", ", args);
 						yield return apiMethod;
@@ -196,7 +195,6 @@ public IEnumerable<CsharpMethod> CsharpMethods
 						yield return apiMethod;
 						
 						//No need for deserialization state when returning dynamicdictionary
-						args = args.Take(args.Count() - 1).ToList();
 
 						var explanationOfDynamic =
 							paraIndent + 
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/ElasticsearchClient.Generated.cshtml b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/ElasticsearchClient.Generated.cshtml
index 5c3b17467a2..30adcc2c7ae 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/ElasticsearchClient.Generated.cshtml
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/ElasticsearchClient.Generated.cshtml
@@ -42,11 +42,10 @@ namespace Elasticsearch.Net
 			{
 		<text>@Raw("///<param name=\"" + part.Name + "\">")@part.Description@Raw("</param>")</text>
 			}
-		<text>@Raw("///<param name=\"queryString\">Optional function to specify any additional querystring parameters for the request.</param>")</text>
-		if (!string.IsNullOrWhiteSpace(method.ReturnTypeGeneric))
-		{ 
-		<text>@Raw("///<param name=\"deserializationState\">Optional state that will be passed to the deserialization call for the response</param>")</text>
-		}
+		<text>@Raw(@"///<param name=""requestParameters"">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>")</text>
 		<text>@Raw("///<returns>"+method.ReturnDescription)
 		///@Raw("</returns>")</text>
 		<text>public @Raw(method.ReturnType) @(method.FullName)@(Raw(method.ReturnTypeGeneric))(@Raw(method.Arguments))
@@ -63,23 +62,21 @@ namespace Elasticsearch.Net
 		{
 	<text>var url = "@(url)";</text>
 		}
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new @(method.QueryStringParamName)());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new @(method.QueryStringParamName)());
+				ToNameValueCollection(requestParams);
 			}
 			@{
 			bool isAsync = method.ReturnType.StartsWith("Task<");
 			string requestMethod = isAsync ? "DoRequestAsync" : "DoRequest";
 			bool wrap = method.ReturnTypeGeneric == null;
 		}
-			return @(wrap ? "ElasticsearchResponse.Wrap"+ (isAsync ? "Async" : "") +"("  : "")this.@(requestMethod)@(Raw(method.ReturnTypeGeneric ?? "<Dictionary<string, object>>"))("@method.HttpMethod", url@(method.Parts.Any(pp=>pp.Name == "body") ? ", body" : ", data: null"), 
-				queryString: nv
-			@if(!string.IsNullOrWhiteSpace(method.ReturnTypeGeneric))
-			{
-				<text>, deserializationState: deserializationState</text>
-			}			)@(wrap ? ")" : "");
+			return @(wrap ? "ElasticsearchResponse.Wrap"+ (isAsync ? "Async" : "") +"("  : "")this.@(requestMethod)@(Raw(method.ReturnTypeGeneric ?? "<Dictionary<string, object>>"))(
+				"@method.HttpMethod", url@(method.Parts.Any(pp=>pp.Name == "body") ? ", body" : ", data: null"), 
+				requestParameters: requestParams
+			)@(wrap ? ")" : "");
 		}</text>
 
 		}
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/IElasticsearchClient.Generated.cshtml b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/IElasticsearchClient.Generated.cshtml
index bca49c16fdb..e85343e14e9 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/IElasticsearchClient.Generated.cshtml
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/IElasticsearchClient.Generated.cshtml
@@ -39,11 +39,10 @@ namespace Elasticsearch.Net
 			{
 		<text>@Raw("///<param name=\""+part.Name+"\">")@part.Description@Raw("</param>")</text>
 			}
-		@Raw("///<param name=\"queryString\">Optional function to specify any additional querystring parameters for the request.</param>")
-		@if (!string.IsNullOrWhiteSpace(method.ReturnTypeGeneric))
-		{ 
-		@Raw("///<param name=\"deserializationState\">Optional state that will be passed to the deserialization call for the response</param>")
-		}
+		@Raw(@"///<param name=""requestParameters"">
+		///Optional function to specify any additional request parameters 
+		///<para>Querystring values, connection configuration specific to this request, deserialization state.</para>
+		///</param>")
 		@Raw("///<returns>"+method.ReturnDescription)
 		///@Raw("</returns>")
 		
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RawDispatch.Generated.cshtml b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RawDispatch.Generated.cshtml
index 196d1c183ff..ccccda65839 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RawDispatch.Generated.cshtml
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/RawDispatch.Generated.cshtml
@@ -36,7 +36,7 @@ namespace Nest
 		foreach(var gen in generate)
 		{
 		<text>
-		internal @Raw(gen.Returns) @(Raw(gen.Name))(ElasticsearchPathInfo<@peek.QueryStringParamName> pathInfo @if (endpoint.Body != null) {<text>, object body</text>}, object deserializationState = null)
+		internal @Raw(gen.Returns) @(Raw(gen.Name))(ElasticsearchPathInfo<@peek.QueryStringParamName> pathInfo @if (endpoint.Body != null) {<text>, object body</text>})
 		{
 			switch(pathInfo.HttpMethod)
 			{
@@ -55,18 +55,18 @@ namespace Nest
 					<text>//@method.HttpMethod @method.Path</text>
 					if (i == 0 && !dispatch.IfChecks.Any())
 					{
-					<text>return this.Raw.@(Raw(name))(@Raw(string.Join(",", dispatch.MethodArguments)), deserializationState);</text>
+					<text>return this.Raw.@(Raw(name))(@Raw(string.Join(",", dispatch.MethodArguments)));</text>
 					}
 					else
 					{
 						if (dispatch.IfChecks.Any())
 						{
 					<text>if (@Raw(string.Join(" && ", dispatch.IfChecks)))
-						return this.Raw.@(Raw(name))(@Raw(string.Join(",", dispatch.MethodArguments)), deserializationState);</text>
+						return this.Raw.@(Raw(name))(@Raw(string.Join(",", dispatch.MethodArguments)));</text>
 						}
 						else
 						{
-					<text>return this.Raw.@(Raw(name))(@Raw(string.Join(",", dispatch.MethodArguments)), deserializationState);</text>
+					<text>return this.Raw.@(Raw(name))(@Raw(string.Join(",", dispatch.MethodArguments)));</text>
 						}
 					}
 					if (i == totalDispatches - 1 && allWithIfChecks)
diff --git a/src/Elasticsearch.Net/Connection/ITransport.cs b/src/Elasticsearch.Net/Connection/ITransport.cs
index 7692ce8f5c6..65c1a93c88e 100644
--- a/src/Elasticsearch.Net/Connection/ITransport.cs
+++ b/src/Elasticsearch.Net/Connection/ITransport.cs
@@ -13,8 +13,7 @@ ElasticsearchResponse<T> DoRequest<T>(
 			string method, 
 			string path, 
 			object data = null, 
-			NameValueCollection queryString = null, 
-			object serializationState = null);
+			IRequestParameters requestParameters = null);
 
 		void Sniff(bool fromStartup = false);
 
@@ -22,8 +21,7 @@ Task<ElasticsearchResponse<T>> DoRequestAsync<T>(
 			string method, 
 			string path, 
 			object data = null, 
-			NameValueCollection queryString = null,
-			object serializationState = null);
+			IRequestParameters requestParameters = null);
 	}
 
 	public interface ITransportValues
diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index b9241083ed2..0a3d6d70e47 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -23,22 +23,26 @@ class TransportRequestState<T>
 		public string Path { get; private set; }
 		public byte[] PostData { get; private set; }
 		public ElasticsearchResponseTracer<T> Tracer { get; private set; }
-		public object DeserializationState { get; private set; }
 
-		public int Retried { get; set; }
 		public int? Seed { get; set; }
 
+		public IConnectionConfigurationOverrides RequestConfiguration { get; set; }
+		public object DeserializationState { get; private set; }
 
-		public TransportRequestState(ElasticsearchResponseTracer<T> tracer, string method, string path, byte[] postData = null, NameValueCollection queryString = null, object deserializationState = null)
+		public TransportRequestState(ElasticsearchResponseTracer<T> tracer, string method, string path, byte[] postData = null, IRequestParameters requestParameters = null)
 		{
 			this.Method = method;
 			this.Path = path;
 			this.PostData = postData;
-			if (queryString != null) this.Path += queryString.ToQueryString();
-			this.DeserializationState = deserializationState;
-
+			if (requestParameters != null)
+			{
+				if (requestParameters.QueryString != null) this.Path += requestParameters.QueryString.ToQueryString();
+				this.DeserializationState = requestParameters.DeserializationState;
+				this.RequestConfiguration = requestParameters.RequestConfiguration;
+			}
 			this.Tracer = tracer;
 		}
+
 	}
 
 	public class Transport : ITransport
@@ -96,12 +100,12 @@ private int GetMaximumRetries()
 		}
 
 		/* SYNC *** */
-		public ElasticsearchResponse<T> DoRequest<T>(string method, string path, object data = null, NameValueCollection queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> DoRequest<T>(string method, string path, object data = null, IRequestParameters requestParameters = null)
 		{
 			using (var tracer = new ElasticsearchResponseTracer<T>(this.Settings.TraceEnabled))
 			{
 				var postData = PostData(data);
-				var requestState = new TransportRequestState<T>(tracer, method, path, postData, queryString, deserializationState);
+				var requestState = new TransportRequestState<T>(tracer, method, path, postData, requestParameters);
 
 				var result = this.DoRequest<T>(requestState);
 				tracer.SetResult(result);
@@ -111,7 +115,7 @@ public ElasticsearchResponse<T> DoRequest<T>(string method, string path, object
 
 		private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestState, int retried = 0)
 		{
-			SniffIfInformationIsTooOld(requestState.Retried);
+			SniffIfInformationIsTooOld(retried);
 
 			IElasticsearchResponse response = null;
 
@@ -127,7 +131,7 @@ private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestSt
 				if (shouldPingHint && !this._configurationValues.DisablePings)
 					this._connection.Ping(CreateUriToPath(baseUri, ""));
 
-				var streamResponse = _doRequest(requestState.Method, uri, requestState.PostData, null);
+				var streamResponse = _doRequest(requestState.Method, uri, requestState.PostData, requestState.RequestConfiguration);
 				if (streamResponse != null && streamResponse.SuccessOrKnownError)
 				{
 					var typedResponse = this.StreamToTypedResponse<T>(streamResponse, requestState.DeserializationState);
@@ -185,12 +189,12 @@ private ElasticsearchResponse<Stream> _doRequest(string method, Uri uri, byte[]
 
 
 		/* ASYNC *** */
-		public Task<ElasticsearchResponse<T>> DoRequestAsync<T>(string method, string path, object data = null, NameValueCollection queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> DoRequestAsync<T>(string method, string path, object data = null, IRequestParameters requestParameters = null)
 		{
 			using (var tracer = new ElasticsearchResponseTracer<T>(this.Settings.TraceEnabled))
 			{
 				var postData = PostData(data);
-				var requestState = new TransportRequestState<T>(tracer, method, path, postData, queryString, deserializationState);
+				var requestState = new TransportRequestState<T>(tracer, method, path, postData, requestParameters);
 
 				return this.DoRequestAsync<T>(requestState)
 					.ContinueWith(t =>
@@ -223,7 +227,7 @@ private Task<ElasticsearchResponse<T>> DoRequestAsync<T>(TransportRequestState<T
 				}
 			}
 			
-			return _doRequestAsync(requestState.Method, uri, requestState.PostData, null).ContinueWith(t =>
+			return _doRequestAsync(requestState.Method, uri, requestState.PostData, requestState.RequestConfiguration).ContinueWith(t =>
 			{
 				if (t.IsCanceled)
 					return null;
diff --git a/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
index e77df0d84f3..ef7ea9f5483 100644
--- a/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
+++ b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
@@ -7,18 +7,45 @@
 
 namespace Elasticsearch.Net
 {
-	/// <summary>
-	/// Used by the raw client to compose querystring parameters in a matter that still exposes some xmldocs
-	/// You can always pass a simple NameValueCollection if you want.
-	/// </summary>
-	/// <typeparam name="T"></typeparam>
-	public abstract class FluentRequestParameters<T> where T : FluentRequestParameters<T>
+	
+	public interface IRequestParameters
+	{
+		NameValueCollection QueryString { get; }
+		object DeserializationState { get; }
+		IConnectionConfigurationOverrides RequestConfiguration { get; }
+
+	}
+
+	public abstract class BaseRequestParameters : IRequestParameters
 	{
 		internal readonly IDictionary<string, object> _QueryStringDictionary = new Dictionary<string, object>();
 		
 		internal object _DeserializationState = null;
 
 		internal IConnectionConfigurationOverrides _RequestConfiguration = null;
+		internal NameValueCollection _queryString;
+
+		NameValueCollection IRequestParameters.QueryString { get { return _queryString;}  }
+
+		object IRequestParameters.DeserializationState
+		{
+			get { return _DeserializationState; }
+		}
+
+		IConnectionConfigurationOverrides IRequestParameters.RequestConfiguration
+		{
+			get { return _RequestConfiguration; }
+		}
+	}
+
+	/// <summary>
+	/// Used by the raw client to compose querystring parameters in a matter that still exposes some xmldocs
+	/// You can always pass a simple NameValueCollection if you want.
+	/// </summary>
+	/// <typeparam name="T"></typeparam>
+	public abstract class FluentRequestParameters<T> : BaseRequestParameters 
+		where T : FluentRequestParameters<T>
+	{
 
 		public T Add(string name, object value)
 		{
diff --git a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
index f1d09510fb4..402c17da3c5 100644
--- a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
@@ -23,25 +23,27 @@ public partial class ElasticsearchClient : IElasticsearchClient
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 	    ///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Bulk<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Bulk<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			var url = "_bulk".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -52,25 +54,27 @@ public ElasticsearchResponse<T> Bulk<T>(object body, Func<BulkRequestParameters,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 	    ///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> BulkAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			var url = "_bulk".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -82,24 +86,28 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(object body, Func<BulkRequest
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 	    ///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Bulk(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Bulk(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			var url = "_bulk".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -111,24 +119,28 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(object body, Func<BulkReque
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 	    ///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			var url = "_bulk".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -140,26 +152,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(object body, Fun
 	    ///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Bulk<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Bulk<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -171,26 +185,28 @@ public ElasticsearchResponse<T> Bulk<T>(string index, object body, Func<BulkRequ
 	    ///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> BulkAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -203,25 +219,29 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, object body, Fu
 	    ///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Bulk(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Bulk(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -234,25 +254,29 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(string index, object body,
 	    ///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -265,27 +289,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, ob
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Bulk<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Bulk<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_bulk".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -298,27 +324,29 @@ public ElasticsearchResponse<T> Bulk<T>(string index, string type, object body,
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> BulkAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_bulk".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -332,26 +360,30 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, string type, ob
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Bulk(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Bulk(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_bulk".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -365,26 +397,30 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(string index, string type,
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_bulk".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -395,25 +431,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, st
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 	    ///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> BulkPut<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> BulkPut<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			var url = "_bulk".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -424,25 +462,27 @@ public ElasticsearchResponse<T> BulkPut<T>(object body, Func<BulkRequestParamete
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 	    ///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> BulkPutAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			var url = "_bulk".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -454,24 +494,28 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(object body, Func<BulkRequ
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 	    ///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> BulkPut(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> BulkPut(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			var url = "_bulk".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -483,24 +527,28 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(object body, Func<BulkRe
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 	    ///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkPutAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			var url = "_bulk".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -512,26 +560,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(object body,
 	    ///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> BulkPut<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> BulkPut<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -543,26 +593,28 @@ public ElasticsearchResponse<T> BulkPut<T>(string index, object body, Func<BulkR
 	    ///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> BulkPutAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -575,25 +627,29 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, object body,
 	    ///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> BulkPut(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -606,25 +662,29 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, object bod
 	    ///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkPutAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_bulk".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -637,27 +697,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index,
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> BulkPut<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> BulkPut<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_bulk".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -670,27 +732,29 @@ public ElasticsearchResponse<T> BulkPut<T>(string index, string type, object bod
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> BulkPutAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_bulk".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -704,26 +768,30 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, string type,
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> BulkPut(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_bulk".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -737,26 +805,30 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, string typ
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkPutAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_bulk".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new BulkRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new BulkRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -766,25 +838,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index,
 		///<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/cat-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatAliases<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatAliases<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/aliases";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -794,25 +868,27 @@ public ElasticsearchResponse<T> CatAliases<T>(Func<CatAliasesRequestParameters,
 		///<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/cat-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatAliasesAsync<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/aliases";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -823,24 +899,28 @@ public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(Func<CatAliasesRequestP
 		///<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/1.x/cat-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/aliases";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -851,24 +931,28 @@ public ElasticsearchResponse<DynamicDictionary> CatAliases(Func<CatAliasesReques
 		///<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/1.x/cat-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/aliases";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -879,26 +963,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(Func<CatAl
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatAliases<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatAliases<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -909,26 +995,28 @@ public ElasticsearchResponse<T> CatAliases<T>(string name, Func<CatAliasesReques
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatAliasesAsync<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -940,25 +1028,29 @@ public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(string name, Func<CatAl
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -970,25 +1062,29 @@ public ElasticsearchResponse<DynamicDictionary> CatAliases(string name, Func<Cat
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -998,25 +1094,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(string nam
 		///<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/cat-allocation.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatAllocation<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatAllocation<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/allocation";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAllocationRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAllocationRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1026,25 +1124,27 @@ public ElasticsearchResponse<T> CatAllocation<T>(Func<CatAllocationRequestParame
 		///<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/cat-allocation.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatAllocationAsync<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/allocation";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAllocationRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAllocationRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1055,24 +1155,28 @@ public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(Func<CatAllocationRe
 		///<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/1.x/cat-allocation.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/allocation";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAllocationRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAllocationRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1083,24 +1187,28 @@ public ElasticsearchResponse<DynamicDictionary> CatAllocation(Func<CatAllocation
 		///<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/1.x/cat-allocation.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/allocation";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAllocationRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAllocationRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1111,26 +1219,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(Func<Ca
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatAllocation<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatAllocation<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAllocationRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAllocationRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1141,26 +1251,28 @@ public ElasticsearchResponse<T> CatAllocation<T>(string node_id, Func<CatAllocat
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatAllocationAsync<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAllocationRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAllocationRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1172,25 +1284,29 @@ public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(string node_id, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAllocationRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAllocationRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1202,25 +1318,29 @@ public ElasticsearchResponse<DynamicDictionary> CatAllocation(string node_id, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatAllocationRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatAllocationRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1230,25 +1350,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(string
 		///<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/cat-count.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatCount<T>(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatCount<T>(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/count";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatCountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatCountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1258,25 +1380,27 @@ public ElasticsearchResponse<T> CatCount<T>(Func<CatCountRequestParameters, CatC
 		///<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/cat-count.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatCountAsync<T>(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatCountAsync<T>(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/count";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatCountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatCountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1287,24 +1411,28 @@ public Task<ElasticsearchResponse<T>> CatCountAsync<T>(Func<CatCountRequestParam
 		///<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/1.x/cat-count.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/count";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatCountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatCountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1315,24 +1443,28 @@ public ElasticsearchResponse<DynamicDictionary> CatCount(Func<CatCountRequestPar
 		///<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/1.x/cat-count.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/count";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatCountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatCountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1343,26 +1475,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(Func<CatCoun
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatCount<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatCount<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatCountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatCountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1373,26 +1507,28 @@ public ElasticsearchResponse<T> CatCount<T>(string index, Func<CatCountRequestPa
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatCountAsync<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatCountAsync<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatCountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatCountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1404,25 +1540,29 @@ public Task<ElasticsearchResponse<T>> CatCountAsync<T>(string index, Func<CatCou
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatCountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatCountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1434,25 +1574,29 @@ public ElasticsearchResponse<DynamicDictionary> CatCount(string index, Func<CatC
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatCountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatCountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1462,25 +1606,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(string index
 		///<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/cat-health.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatHealth<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatHealth<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/health";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1490,25 +1636,27 @@ public ElasticsearchResponse<T> CatHealth<T>(Func<CatHealthRequestParameters, Ca
 		///<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/cat-health.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatHealthAsync<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatHealthAsync<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/health";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1519,24 +1667,28 @@ public Task<ElasticsearchResponse<T>> CatHealthAsync<T>(Func<CatHealthRequestPar
 		///<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/1.x/cat-health.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/health";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1547,24 +1699,28 @@ public ElasticsearchResponse<DynamicDictionary> CatHealth(Func<CatHealthRequestP
 		///<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/1.x/cat-health.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/health";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1574,25 +1730,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatHealthAsync(Func<CatHea
 		///<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/cat.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatHelp<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatHelp<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null)
 		{
 			var url = "_cat";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatHelpRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatHelpRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1602,25 +1760,27 @@ public ElasticsearchResponse<T> CatHelp<T>(Func<CatHelpRequestParameters, CatHel
 		///<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/cat.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatHelpAsync<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatHelpAsync<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null)
 		{
 			var url = "_cat";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatHelpRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatHelpRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1631,24 +1791,28 @@ public Task<ElasticsearchResponse<T>> CatHelpAsync<T>(Func<CatHelpRequestParamet
 		///<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/1.x/cat.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null)
 		{
 			var url = "_cat";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatHelpRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatHelpRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1659,24 +1823,28 @@ public ElasticsearchResponse<DynamicDictionary> CatHelp(Func<CatHelpRequestParam
 		///<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/1.x/cat.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null)
 		{
 			var url = "_cat";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatHelpRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatHelpRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1686,25 +1854,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatHelpAsync(Func<CatHelpR
 		///<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/cat-indices.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatIndices<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatIndices<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/indices";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatIndicesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatIndicesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1714,25 +1884,27 @@ public ElasticsearchResponse<T> CatIndices<T>(Func<CatIndicesRequestParameters,
 		///<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/cat-indices.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatIndicesAsync<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/indices";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatIndicesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatIndicesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1743,24 +1915,28 @@ public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(Func<CatIndicesRequestP
 		///<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/1.x/cat-indices.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/indices";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatIndicesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatIndicesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1771,24 +1947,28 @@ public ElasticsearchResponse<DynamicDictionary> CatIndices(Func<CatIndicesReques
 		///<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/1.x/cat-indices.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/indices";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatIndicesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatIndicesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1799,26 +1979,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(Func<CatIn
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatIndices<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatIndices<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatIndicesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatIndicesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1829,26 +2011,28 @@ public ElasticsearchResponse<T> CatIndices<T>(string index, Func<CatIndicesReque
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatIndicesAsync<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatIndicesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatIndicesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1860,25 +2044,29 @@ public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(string index, Func<CatI
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatIndicesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatIndicesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1890,25 +2078,29 @@ public ElasticsearchResponse<DynamicDictionary> CatIndices(string index, Func<Ca
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatIndicesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatIndicesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -1918,25 +2110,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(string ind
 		///<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/cat-master.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatMaster<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatMaster<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/master";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatMasterRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatMasterRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1946,25 +2140,27 @@ public ElasticsearchResponse<T> CatMaster<T>(Func<CatMasterRequestParameters, Ca
 		///<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/cat-master.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatMasterAsync<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatMasterAsync<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/master";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatMasterRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatMasterRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -1975,24 +2171,28 @@ public Task<ElasticsearchResponse<T>> CatMasterAsync<T>(Func<CatMasterRequestPar
 		///<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/1.x/cat-master.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/master";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatMasterRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatMasterRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2003,24 +2203,28 @@ public ElasticsearchResponse<DynamicDictionary> CatMaster(Func<CatMasterRequestP
 		///<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/1.x/cat-master.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/master";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatMasterRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatMasterRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2030,25 +2234,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatMasterAsync(Func<CatMas
 		///<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/cat-nodes.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatNodes<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatNodes<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/nodes";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatNodesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatNodesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2058,25 +2264,27 @@ public ElasticsearchResponse<T> CatNodes<T>(Func<CatNodesRequestParameters, CatN
 		///<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/cat-nodes.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatNodesAsync<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatNodesAsync<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/nodes";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatNodesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatNodesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2087,24 +2295,28 @@ public Task<ElasticsearchResponse<T>> CatNodesAsync<T>(Func<CatNodesRequestParam
 		///<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/1.x/cat-nodes.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/nodes";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatNodesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatNodesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2115,24 +2327,28 @@ public ElasticsearchResponse<DynamicDictionary> CatNodes(Func<CatNodesRequestPar
 		///<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/1.x/cat-nodes.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/nodes";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatNodesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatNodesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2142,25 +2358,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatNodesAsync(Func<CatNode
 		///<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/cat-pending-tasks.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatPendingTasks<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatPendingTasks<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/pending_tasks";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatPendingTasksRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatPendingTasksRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2170,25 +2388,27 @@ public ElasticsearchResponse<T> CatPendingTasks<T>(Func<CatPendingTasksRequestPa
 		///<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/cat-pending-tasks.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatPendingTasksAsync<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatPendingTasksAsync<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/pending_tasks";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatPendingTasksRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatPendingTasksRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2199,24 +2419,28 @@ public Task<ElasticsearchResponse<T>> CatPendingTasksAsync<T>(Func<CatPendingTas
 		///<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/1.x/cat-pending-tasks.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/pending_tasks";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatPendingTasksRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatPendingTasksRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2227,24 +2451,28 @@ public ElasticsearchResponse<DynamicDictionary> CatPendingTasks(Func<CatPendingT
 		///<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/1.x/cat-pending-tasks.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/pending_tasks";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatPendingTasksRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatPendingTasksRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2254,25 +2482,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatPendingTasksAsync(Func<
 		///<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/cat-recovery.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatRecovery<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatRecovery<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/recovery";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatRecoveryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2282,25 +2512,27 @@ public ElasticsearchResponse<T> CatRecovery<T>(Func<CatRecoveryRequestParameters
 		///<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/cat-recovery.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatRecoveryAsync<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/recovery";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatRecoveryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2311,24 +2543,28 @@ public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(Func<CatRecoveryReques
 		///<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/1.x/cat-recovery.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/recovery";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatRecoveryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2339,24 +2575,28 @@ public ElasticsearchResponse<DynamicDictionary> CatRecovery(Func<CatRecoveryRequ
 		///<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/1.x/cat-recovery.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/recovery";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatRecoveryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2367,26 +2607,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(Func<CatR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatRecovery<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatRecovery<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatRecoveryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2397,26 +2639,28 @@ public ElasticsearchResponse<T> CatRecovery<T>(string index, Func<CatRecoveryReq
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatRecoveryAsync<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatRecoveryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2428,25 +2672,29 @@ public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(string index, Func<Cat
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatRecoveryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2458,25 +2706,29 @@ public ElasticsearchResponse<DynamicDictionary> CatRecovery(string index, Func<C
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatRecoveryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2486,25 +2738,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(string in
 		///<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/cat-shards.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatShards<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatShards<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/shards";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatShardsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatShardsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2514,25 +2768,27 @@ public ElasticsearchResponse<T> CatShards<T>(Func<CatShardsRequestParameters, Ca
 		///<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/cat-shards.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatShardsAsync<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/shards";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatShardsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatShardsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2543,24 +2799,28 @@ public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(Func<CatShardsRequestPar
 		///<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/1.x/cat-shards.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/shards";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatShardsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatShardsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2571,24 +2831,28 @@ public ElasticsearchResponse<DynamicDictionary> CatShards(Func<CatShardsRequestP
 		///<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/1.x/cat-shards.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/shards";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatShardsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatShardsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2599,26 +2863,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(Func<CatSha
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatShards<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatShards<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatShardsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatShardsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2629,26 +2895,28 @@ public ElasticsearchResponse<T> CatShards<T>(string index, Func<CatShardsRequest
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatShardsAsync<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatShardsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatShardsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2660,25 +2928,29 @@ public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(string index, Func<CatSh
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatShardsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatShardsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2690,25 +2962,29 @@ public ElasticsearchResponse<DynamicDictionary> CatShards(string index, Func<Cat
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatShardsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatShardsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2718,25 +2994,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(string inde
 		///<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/cat-thread-pool.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CatThreadPool<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CatThreadPool<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/thread_pool";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatThreadPoolRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatThreadPoolRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2746,25 +3024,27 @@ public ElasticsearchResponse<T> CatThreadPool<T>(Func<CatThreadPoolRequestParame
 		///<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/cat-thread-pool.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CatThreadPoolAsync<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CatThreadPoolAsync<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/thread_pool";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatThreadPoolRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatThreadPoolRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2775,24 +3055,28 @@ public Task<ElasticsearchResponse<T>> CatThreadPoolAsync<T>(Func<CatThreadPoolRe
 		///<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/cat-thread-pool.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/thread_pool";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatThreadPoolRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatThreadPoolRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2803,24 +3087,28 @@ public ElasticsearchResponse<DynamicDictionary> CatThreadPool(Func<CatThreadPool
 		///<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/cat-thread-pool.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/thread_pool";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CatThreadPoolRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CatThreadPoolRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2831,26 +3119,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CatThreadPoolAsync(Func<Ca
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="scroll_id">A comma-separated list of scroll IDs to clear</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClearScroll<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClearScroll<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2861,26 +3151,28 @@ public ElasticsearchResponse<T> ClearScroll<T>(string scroll_id, Func<ClearScrol
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="scroll_id">A comma-separated list of scroll IDs to clear</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClearScrollAsync<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClearScrollAsync<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2892,25 +3184,29 @@ public Task<ElasticsearchResponse<T>> ClearScrollAsync<T>(string scroll_id, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="scroll_id">A comma-separated list of scroll IDs to clear</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClearScroll(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClearScroll(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2922,25 +3218,29 @@ public ElasticsearchResponse<DynamicDictionary> ClearScroll(string scroll_id, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="scroll_id">A comma-separated list of scroll IDs to clear</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClearScrollAsync(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClearScrollAsync(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -2950,25 +3250,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClearScrollAsync(string sc
 		///<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/cluster-update-settings.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterGetSettings<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterGetSettings<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/settings";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterGetSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterGetSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -2978,25 +3280,27 @@ public ElasticsearchResponse<T> ClusterGetSettings<T>(Func<ClusterGetSettingsReq
 		///<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/cluster-update-settings.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterGetSettingsAsync<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterGetSettingsAsync<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/settings";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterGetSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterGetSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3007,24 +3311,28 @@ public Task<ElasticsearchResponse<T>> ClusterGetSettingsAsync<T>(Func<ClusterGet
 		///<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/1.x/cluster-update-settings.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterGetSettings(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterGetSettings(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/settings";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterGetSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterGetSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3035,24 +3343,28 @@ public ElasticsearchResponse<DynamicDictionary> ClusterGetSettings(Func<ClusterG
 		///<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/1.x/cluster-update-settings.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterGetSettingsAsync(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterGetSettingsAsync(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/settings";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterGetSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterGetSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3062,25 +3374,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterGetSettingsAsync(Fu
 		///<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/cluster-health.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterHealth<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterHealth<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/health";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3090,25 +3404,27 @@ public ElasticsearchResponse<T> ClusterHealth<T>(Func<ClusterHealthRequestParame
 		///<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/cluster-health.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterHealthAsync<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/health";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3119,24 +3435,28 @@ public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(Func<ClusterHealthRe
 		///<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/1.x/cluster-health.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterHealth(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterHealth(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/health";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3147,24 +3467,28 @@ public ElasticsearchResponse<DynamicDictionary> ClusterHealth(Func<ClusterHealth
 		///<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/1.x/cluster-health.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterHealthAsync(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/health";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3175,26 +3499,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(Func<Cl
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html</para>	
 	    ///</summary>
 		///<param name="index">Limit the information returned to a specific index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterHealth<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterHealth<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/health/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3205,26 +3531,28 @@ public ElasticsearchResponse<T> ClusterHealth<T>(string index, Func<ClusterHealt
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html</para>	
 	    ///</summary>
 		///<param name="index">Limit the information returned to a specific index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterHealthAsync<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/health/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3236,25 +3564,29 @@ public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(string index, Func<C
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html</para>	
 	    ///</summary>
 		///<param name="index">Limit the information returned to a specific index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterHealth(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterHealth(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/health/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3266,25 +3598,29 @@ public ElasticsearchResponse<DynamicDictionary> ClusterHealth(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html</para>	
 	    ///</summary>
 		///<param name="index">Limit the information returned to a specific index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterHealthAsync(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/health/{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterHealthRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterHealthRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3294,25 +3630,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(string
 		///<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/cluster-pending.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterPendingTasks<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterPendingTasks<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/pending_tasks";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterPendingTasksRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterPendingTasksRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3322,25 +3660,27 @@ public ElasticsearchResponse<T> ClusterPendingTasks<T>(Func<ClusterPendingTasksR
 		///<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/cluster-pending.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterPendingTasksAsync<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterPendingTasksAsync<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/pending_tasks";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterPendingTasksRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterPendingTasksRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3351,24 +3691,28 @@ public Task<ElasticsearchResponse<T>> ClusterPendingTasksAsync<T>(Func<ClusterPe
 		///<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/1.x/cluster-pending.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterPendingTasks(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterPendingTasks(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/pending_tasks";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterPendingTasksRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterPendingTasksRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3379,24 +3723,28 @@ public ElasticsearchResponse<DynamicDictionary> ClusterPendingTasks(Func<Cluster
 		///<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/1.x/cluster-pending.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterPendingTasksAsync(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPendingTasksAsync(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/pending_tasks";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterPendingTasksRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterPendingTasksRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3407,25 +3755,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPendingTasksAsync(F
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html</para>	
 	    ///</summary>
 		///<param name="body">The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart).</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterPutSettings<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterPutSettings<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/settings".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterPutSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterPutSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3436,25 +3786,27 @@ public ElasticsearchResponse<T> ClusterPutSettings<T>(object body, Func<ClusterP
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html</para>	
 	    ///</summary>
 		///<param name="body">The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart).</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterPutSettingsAsync<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterPutSettingsAsync<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/settings".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterPutSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterPutSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3466,24 +3818,28 @@ public Task<ElasticsearchResponse<T>> ClusterPutSettingsAsync<T>(object body, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html</para>	
 	    ///</summary>
 		///<param name="body">The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart).</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterPutSettings(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterPutSettings(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/settings".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterPutSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterPutSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3495,24 +3851,28 @@ public ElasticsearchResponse<DynamicDictionary> ClusterPutSettings(object body,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html</para>	
 	    ///</summary>
 		///<param name="body">The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart).</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterPutSettingsAsync(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPutSettingsAsync(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/settings".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterPutSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterPutSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3523,25 +3883,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPutSettingsAsync(ob
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html</para>	
 	    ///</summary>
 		///<param name="body">The definition of `commands` to perform (`move`, `cancel`, `allocate`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterReroute<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterReroute<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/reroute".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterRerouteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterRerouteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3552,25 +3914,27 @@ public ElasticsearchResponse<T> ClusterReroute<T>(object body, Func<ClusterRerou
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html</para>	
 	    ///</summary>
 		///<param name="body">The definition of `commands` to perform (`move`, `cancel`, `allocate`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterRerouteAsync<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterRerouteAsync<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/reroute".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterRerouteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterRerouteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3582,24 +3946,28 @@ public Task<ElasticsearchResponse<T>> ClusterRerouteAsync<T>(object body, Func<C
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html</para>	
 	    ///</summary>
 		///<param name="body">The definition of `commands` to perform (`move`, `cancel`, `allocate`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterReroute(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterReroute(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/reroute".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterRerouteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterRerouteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3611,24 +3979,28 @@ public ElasticsearchResponse<DynamicDictionary> ClusterReroute(object body, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html</para>	
 	    ///</summary>
 		///<param name="body">The definition of `commands` to perform (`move`, `cancel`, `allocate`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterRerouteAsync(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterRerouteAsync(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/reroute".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterRerouteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterRerouteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3638,25 +4010,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterRerouteAsync(object
 		///<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/cluster-state.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterState<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterState<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/state";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3666,25 +4040,27 @@ public ElasticsearchResponse<T> ClusterState<T>(Func<ClusterStateRequestParamete
 		///<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/cluster-state.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterStateAsync<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/state";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3695,24 +4071,28 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(Func<ClusterStateRequ
 		///<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/1.x/cluster-state.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterState(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterState(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/state";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3723,24 +4103,28 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(Func<ClusterStateRe
 		///<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/1.x/cluster-state.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStateAsync(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/state";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3751,26 +4135,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(Func<Clu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterState<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterState<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_cluster/state/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3781,26 +4167,28 @@ public ElasticsearchResponse<T> ClusterState<T>(string metric, Func<ClusterState
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterStateAsync<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_cluster/state/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3812,25 +4200,29 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, Func<C
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterState(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_cluster/state/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3842,25 +4234,29 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStateAsync(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_cluster/state/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3872,27 +4268,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string m
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterState<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterState<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/state/{0}/{1}".F(Encoded(metric), Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3904,27 +4302,29 @@ public ElasticsearchResponse<T> ClusterState<T>(string metric, string index, Fun
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterStateAsync<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/state/{0}/{1}".F(Encoded(metric), Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -3937,26 +4337,30 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, string
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterState(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/state/{0}/{1}".F(Encoded(metric), Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3969,26 +4373,30 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, stri
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStateAsync(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cluster/state/{0}/{1}".F(Encoded(metric), Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -3998,25 +4406,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string m
 		///<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/cluster-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterStats<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterStats<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4026,25 +4436,27 @@ public ElasticsearchResponse<T> ClusterStats<T>(Func<ClusterStatsRequestParamete
 		///<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/cluster-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterStatsAsync<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4055,24 +4467,28 @@ public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(Func<ClusterStatsRequ
 		///<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/1.x/cluster-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterStats(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterStats(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4083,24 +4499,28 @@ public ElasticsearchResponse<DynamicDictionary> ClusterStats(Func<ClusterStatsRe
 		///<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/1.x/cluster-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStatsAsync(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4111,26 +4531,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(Func<Clu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ClusterStats<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ClusterStats<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/stats/nodes/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4141,26 +4563,28 @@ public ElasticsearchResponse<T> ClusterStats<T>(string node_id, Func<ClusterStat
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ClusterStatsAsync<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/stats/nodes/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4172,25 +4596,29 @@ public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(string node_id, Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterStats(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ClusterStats(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/stats/nodes/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4202,25 +4630,29 @@ public ElasticsearchResponse<DynamicDictionary> ClusterStats(string node_id, Fun
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStatsAsync(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/stats/nodes/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClusterStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClusterStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4231,25 +4663,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(string n
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 	    ///</summary>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Count<T>(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Count<T>(object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			var url = "_count".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4260,25 +4694,27 @@ public ElasticsearchResponse<T> Count<T>(object body, Func<CountRequestParameter
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 	    ///</summary>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountAsync<T>(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountAsync<T>(object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			var url = "_count".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4290,24 +4726,28 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(object body, Func<CountReque
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 	    ///</summary>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Count(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Count(object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			var url = "_count".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4319,24 +4759,28 @@ public ElasticsearchResponse<DynamicDictionary> Count(object body, Func<CountReq
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 	    ///</summary>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountAsync(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			var url = "_count".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4348,26 +4792,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(object body, Fu
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Count<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Count<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4379,26 +4825,28 @@ public ElasticsearchResponse<T> Count<T>(string index, object body, Func<CountRe
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountAsync<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4411,25 +4859,29 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, object body, F
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Count(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Count(string index, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4442,25 +4894,29 @@ public ElasticsearchResponse<DynamicDictionary> Count(string index, object body,
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountAsync(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4473,27 +4929,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, o
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Count<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Count<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4506,27 +4964,29 @@ public ElasticsearchResponse<T> Count<T>(string index, string type, object body,
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountAsync<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4540,26 +5000,30 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, string type, o
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Count(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Count(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4573,26 +5037,30 @@ public ElasticsearchResponse<DynamicDictionary> Count(string index, string type,
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountAsync(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4602,25 +5070,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, s
 		///<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/search-count.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CountGet<T>(Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountGet<T>(Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			var url = "_count";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4630,25 +5100,27 @@ public ElasticsearchResponse<T> CountGet<T>(Func<CountRequestParameters, CountRe
 		///<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/search-count.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountGetAsync<T>(Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountGetAsync<T>(Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			var url = "_count";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4659,24 +5131,28 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(Func<CountRequestParamete
 		///<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/1.x/search-count.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountGet(Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountGet(Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			var url = "_count";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4687,24 +5163,28 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(Func<CountRequestParame
 		///<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/1.x/search-count.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountGetAsync(Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			var url = "_count";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4715,26 +5195,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(Func<CountRe
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CountGet<T>(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountGet<T>(string index, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4745,26 +5227,28 @@ public ElasticsearchResponse<T> CountGet<T>(string index, Func<CountRequestParam
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountGetAsync<T>(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4776,25 +5260,29 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, Func<CountR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountGet(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountGet(string index, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4806,25 +5294,29 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(string index, Func<Coun
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountGetAsync(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_count".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4836,27 +5328,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CountGet<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountGet<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4868,27 +5362,29 @@ public ElasticsearchResponse<T> CountGet<T>(string index, string type, Func<Coun
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountGetAsync<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4901,26 +5397,30 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, string type
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountGet(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountGet(string index, string type, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4933,26 +5433,30 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(string index, string ty
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountGetAsync(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, string type, Func<CountRequestParameters, CountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -4964,27 +5468,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CountPercolateGet<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate/count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -4996,27 +5502,29 @@ public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type,
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountPercolateGetAsync<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate/count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5029,26 +5537,30 @@ public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, st
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountPercolateGet(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate/count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5061,26 +5573,30 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index,
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountPercolateGetAsync(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate/count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5093,28 +5609,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(str
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CountPercolateGet<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate/count".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5127,28 +5645,30 @@ public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type,
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountPercolateGetAsync<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate/count".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5162,27 +5682,31 @@ public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, st
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountPercolateGet(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate/count".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5196,27 +5720,31 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index,
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountPercolateGetAsync(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate/count".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5229,27 +5757,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(str
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CountPercolate<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate/count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5262,27 +5792,29 @@ public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, obj
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountPercolateAsync<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate/count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5296,26 +5828,30 @@ public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, strin
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountPercolate(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate/count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5329,26 +5865,30 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, str
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountPercolateAsync(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate/count".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5362,28 +5902,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> CountPercolate<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate/count".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5397,28 +5939,30 @@ public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, str
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> CountPercolateAsync<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate/count".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5433,27 +5977,31 @@ public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, strin
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountPercolate(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate/count".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5468,27 +6016,31 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, str
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountPercolateAsync(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate/count".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CountPercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CountPercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5501,28 +6053,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Delete<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Delete<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5535,28 +6089,30 @@ public ElasticsearchResponse<T> Delete<T>(string index, string type, string id,
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> DeleteAsync<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> DeleteAsync<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5570,27 +6126,31 @@ public Task<ElasticsearchResponse<T>> DeleteAsync<T>(string index, string type,
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Delete(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Delete(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5604,27 +6164,31 @@ public ElasticsearchResponse<DynamicDictionary> Delete(string index, string type
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> DeleteAsync(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> DeleteAsync(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5636,26 +6200,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteAsync(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> DeleteByQuery<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> DeleteByQuery<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteByQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteByQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5667,26 +6233,28 @@ public ElasticsearchResponse<T> DeleteByQuery<T>(string index, object body, Func
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> DeleteByQueryAsync<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteByQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteByQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5699,25 +6267,29 @@ public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, object
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> DeleteByQuery(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteByQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteByQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5730,25 +6302,29 @@ public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, obje
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> DeleteByQueryAsync(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteByQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteByQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5761,27 +6337,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of types to restrict the operation</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> DeleteByQuery<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> DeleteByQuery<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteByQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteByQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5794,27 +6372,29 @@ public ElasticsearchResponse<T> DeleteByQuery<T>(string index, string type, obje
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of types to restrict the operation</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> DeleteByQueryAsync<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteByQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteByQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5828,26 +6408,30 @@ public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, string
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of types to restrict the operation</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> DeleteByQuery(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteByQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteByQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5861,26 +6445,30 @@ public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, stri
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of types to restrict the operation</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> DeleteByQueryAsync(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteByQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteByQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5893,28 +6481,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Exists<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Exists<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExistsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExistsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5927,28 +6517,30 @@ public ElasticsearchResponse<T> Exists<T>(string index, string type, string id,
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ExistsAsync<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ExistsAsync<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExistsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExistsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -5962,27 +6554,31 @@ public Task<ElasticsearchResponse<T>> ExistsAsync<T>(string index, string type,
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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> Exists(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Exists(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExistsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExistsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -5996,27 +6592,31 @@ public ElasticsearchResponse<DynamicDictionary> Exists(string index, string type
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ExistsAsync(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ExistsAsync(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExistsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExistsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6029,28 +6629,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExistsAsync(string index,
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ExplainGet<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ExplainGet<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_explain".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExplainRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExplainRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6063,28 +6665,30 @@ public ElasticsearchResponse<T> ExplainGet<T>(string index, string type, string
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ExplainGetAsync<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ExplainGetAsync<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_explain".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExplainRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExplainRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6098,27 +6702,31 @@ public Task<ElasticsearchResponse<T>> ExplainGetAsync<T>(string index, string ty
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ExplainGet(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ExplainGet(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_explain".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExplainRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExplainRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6132,27 +6740,31 @@ public ElasticsearchResponse<DynamicDictionary> ExplainGet(string index, string
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ExplainGetAsync(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_explain".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExplainRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExplainRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6166,28 +6778,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string ind
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
 		///<param name="body">The query definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Explain<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Explain<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_explain".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExplainRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExplainRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6201,28 +6815,30 @@ public ElasticsearchResponse<T> Explain<T>(string index, string type, string id,
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
 		///<param name="body">The query definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ExplainAsync<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ExplainAsync<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_explain".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExplainRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExplainRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6237,27 +6853,31 @@ public Task<ElasticsearchResponse<T>> ExplainAsync<T>(string index, string type,
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
 		///<param name="body">The query definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Explain(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Explain(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_explain".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExplainRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExplainRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6272,27 +6892,31 @@ public ElasticsearchResponse<DynamicDictionary> Explain(string index, string typ
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
 		///<param name="body">The query definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ExplainAsync(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ExplainAsync(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_explain".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ExplainRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ExplainRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6305,28 +6929,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExplainAsync(string index,
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Get<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Get<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6339,28 +6965,30 @@ public ElasticsearchResponse<T> Get<T>(string index, string type, string id, Fun
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> GetAsync<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> GetAsync<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6374,27 +7002,31 @@ public Task<ElasticsearchResponse<T>> GetAsync<T>(string index, string type, str
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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> Get(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Get(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6408,27 +7040,31 @@ public ElasticsearchResponse<DynamicDictionary> Get(string index, string type, s
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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>> GetAsync(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6441,28 +7077,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, str
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> queryString = null, object deserializationState = null)
+		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));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SourceRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SourceRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6475,28 +7113,30 @@ public ElasticsearchResponse<T> GetSource<T>(string index, string type, string i
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> queryString = null, object deserializationState = null)
+		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));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SourceRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SourceRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6510,27 +7150,31 @@ public Task<ElasticsearchResponse<T>> GetSourceAsync<T>(string index, string typ
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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> GetSource(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> GetSource(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));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SourceRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SourceRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6544,27 +7188,31 @@ public ElasticsearchResponse<DynamicDictionary> GetSource(string index, string t
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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>> GetSourceAsync(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(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));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SourceRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SourceRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6577,27 +7225,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string inde
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Index<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Index<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6610,27 +7260,29 @@ public ElasticsearchResponse<T> Index<T>(string index, string type, object body,
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndexAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6644,26 +7296,30 @@ public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, o
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Index(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Index(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6677,26 +7333,30 @@ public ElasticsearchResponse<DynamicDictionary> Index(string index, string type,
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndexAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6710,28 +7370,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, s
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Index<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Index<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6745,28 +7407,30 @@ public ElasticsearchResponse<T> Index<T>(string index, string type, string id, o
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndexAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6781,27 +7445,31 @@ public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, s
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Index(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Index(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6816,27 +7484,31 @@ public ElasticsearchResponse<DynamicDictionary> Index(string index, string type,
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndexAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6849,27 +7521,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, s
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndexPut<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndexPut<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6882,27 +7556,29 @@ public ElasticsearchResponse<T> IndexPut<T>(string index, string type, object bo
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndexPutAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -6916,26 +7592,30 @@ public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndexPut(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6949,26 +7629,30 @@ public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string ty
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndexPutAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -6982,28 +7666,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndexPut<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndexPut<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7017,28 +7703,30 @@ public ElasticsearchResponse<T> IndexPut<T>(string index, string type, string id
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndexPutAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7053,27 +7741,31 @@ public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndexPut(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7088,27 +7780,31 @@ public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string ty
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndexPutAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7118,25 +7814,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index
 		///<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/indices-analyze.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesAnalyzeGetForAll<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesAnalyzeGetForAll<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			var url = "_analyze";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7146,25 +7844,27 @@ public ElasticsearchResponse<T> IndicesAnalyzeGetForAll<T>(Func<AnalyzeRequestPa
 		///<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/indices-analyze.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesAnalyzeGetForAllAsync<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetForAllAsync<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			var url = "_analyze";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7175,24 +7875,28 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetForAllAsync<T>(Func<Analy
 		///<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/1.x/indices-analyze.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesAnalyzeGetForAll(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGetForAll(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			var url = "_analyze";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7203,24 +7907,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGetForAll(Func<Ana
 		///<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/1.x/indices-analyze.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesAnalyzeGetForAllAsync(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetForAllAsync(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			var url = "_analyze";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7231,26 +7939,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetForAllAsy
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesAnalyzeGet<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesAnalyzeGet<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7261,26 +7971,28 @@ public ElasticsearchResponse<T> IndicesAnalyzeGet<T>(string index, Func<AnalyzeR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesAnalyzeGetAsync<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetAsync<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7292,25 +8004,29 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetAsync<T>(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesAnalyzeGet(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGet(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7322,25 +8038,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGet(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesAnalyzeGetAsync(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetAsync(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7351,25 +8071,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetAsync(str
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 	    ///</summary>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesAnalyzeForAll<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesAnalyzeForAll<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			var url = "_analyze".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7380,25 +8102,27 @@ public ElasticsearchResponse<T> IndicesAnalyzeForAll<T>(object body, Func<Analyz
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 	    ///</summary>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesAnalyzeForAllAsync<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesAnalyzeForAllAsync<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			var url = "_analyze".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7410,24 +8134,28 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeForAllAsync<T>(object body,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 	    ///</summary>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesAnalyzeForAll(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeForAll(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			var url = "_analyze".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7439,24 +8167,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeForAll(object body
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 	    ///</summary>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesAnalyzeForAllAsync(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeForAllAsync(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			var url = "_analyze".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7468,26 +8200,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeForAllAsync(
 	    ///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesAnalyze<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesAnalyze<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7499,26 +8233,28 @@ public ElasticsearchResponse<T> IndicesAnalyze<T>(string index, object body, Fun
 	    ///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesAnalyzeAsync<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesAnalyzeAsync<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7531,25 +8267,29 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeAsync<T>(string index, objec
 	    ///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesAnalyze(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesAnalyze(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7562,25 +8302,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyze(string index, obj
 	    ///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesAnalyzeAsync(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeAsync(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_analyze".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AnalyzeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AnalyzeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7590,25 +8334,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeAsync(string
 		///<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/indices-clearcache.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesClearCacheForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClearCacheForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			var url = "_cache/clear";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7618,25 +8364,27 @@ public ElasticsearchResponse<T> IndicesClearCacheForAll<T>(Func<ClearCacheReques
 		///<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/indices-clearcache.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesClearCacheForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesClearCacheForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			var url = "_cache/clear";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7647,24 +8395,28 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheForAllAsync<T>(Func<Clear
 		///<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/1.x/indices-clearcache.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClearCacheForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			var url = "_cache/clear";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7675,24 +8427,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheForAll(Func<Cle
 		///<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/1.x/indices-clearcache.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesClearCacheForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			var url = "_cache/clear";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7703,26 +8459,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheForAllAsy
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesClearCache<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClearCache<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7733,26 +8491,28 @@ public ElasticsearchResponse<T> IndicesClearCache<T>(string index, Func<ClearCac
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesClearCacheAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesClearCacheAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7764,25 +8524,29 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheAsync<T>(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClearCache(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClearCache(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7794,25 +8558,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCache(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesClearCacheAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7822,25 +8590,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheAsync(str
 		///<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/indices-clearcache.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesClearCacheGetForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClearCacheGetForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			var url = "_cache/clear";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7850,25 +8620,27 @@ public ElasticsearchResponse<T> IndicesClearCacheGetForAll<T>(Func<ClearCacheReq
 		///<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/indices-clearcache.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesClearCacheGetForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesClearCacheGetForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			var url = "_cache/clear";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7879,24 +8651,28 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheGetForAllAsync<T>(Func<Cl
 		///<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/1.x/indices-clearcache.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClearCacheGetForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGetForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			var url = "_cache/clear";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7907,24 +8683,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGetForAll(Func<
 		///<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/1.x/indices-clearcache.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesClearCacheGetForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			var url = "_cache/clear";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -7935,26 +8715,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetForAll
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesClearCacheGet<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClearCacheGet<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7965,26 +8747,28 @@ public ElasticsearchResponse<T> IndicesClearCacheGet<T>(string index, Func<Clear
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesClearCacheGetAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesClearCacheGetAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -7996,25 +8780,29 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheGetAsync<T>(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClearCacheGet(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGet(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8026,25 +8814,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGet(string inde
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesClearCacheGetAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_cache/clear".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ClearCacheRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ClearCacheRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8055,26 +8847,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetAsync(
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesClose<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesClose<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_close".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CloseIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CloseIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8085,26 +8879,28 @@ public ElasticsearchResponse<T> IndicesClose<T>(string index, Func<CloseIndexReq
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesCloseAsync<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesCloseAsync<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_close".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CloseIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CloseIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8116,25 +8912,29 @@ public Task<ElasticsearchResponse<T>> IndicesCloseAsync<T>(string index, Func<Cl
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClose(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesClose(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_close".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CloseIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CloseIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8146,25 +8946,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClose(string index, Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesCloseAsync(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCloseAsync(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_close".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CloseIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CloseIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8176,26 +8980,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCloseAsync(string i
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesCreate<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesCreate<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CreateIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CreateIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8207,26 +9013,28 @@ public ElasticsearchResponse<T> IndicesCreate<T>(string index, object body, Func
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesCreateAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesCreateAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CreateIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CreateIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8239,25 +9047,29 @@ public Task<ElasticsearchResponse<T>> IndicesCreateAsync<T>(string index, object
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesCreate(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesCreate(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CreateIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CreateIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8270,25 +9082,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesCreate(string index, obje
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesCreateAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreateAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CreateIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CreateIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8300,26 +9116,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreateAsync(string
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesCreatePost<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesCreatePost<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CreateIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CreateIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8331,26 +9149,28 @@ public ElasticsearchResponse<T> IndicesCreatePost<T>(string index, object body,
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesCreatePostAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesCreatePostAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CreateIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CreateIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8363,25 +9183,29 @@ public Task<ElasticsearchResponse<T>> IndicesCreatePostAsync<T>(string index, ob
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesCreatePost(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesCreatePost(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CreateIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CreateIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8394,25 +9218,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesCreatePost(string index,
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesCreatePostAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreatePostAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new CreateIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new CreateIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8423,26 +9251,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreatePostAsync(str
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesDelete<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDelete<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8453,26 +9283,28 @@ public ElasticsearchResponse<T> IndicesDelete<T>(string index, Func<DeleteIndexR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesDeleteAsync<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteAsync<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8484,25 +9316,29 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteAsync<T>(string index, Func<D
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDelete(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDelete(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8514,25 +9350,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDelete(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteAsync(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAsync(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8544,27 +9384,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAsync(string
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="name">A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesDeleteAlias<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDeleteAlias<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesDeleteAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesDeleteAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8576,27 +9418,29 @@ public ElasticsearchResponse<T> IndicesDeleteAlias<T>(string index, string name,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="name">A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesDeleteAliasAsync<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteAliasAsync<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesDeleteAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesDeleteAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8609,26 +9453,30 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteAliasAsync<T>(string index, s
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="name">A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDeleteAlias(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDeleteAlias(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesDeleteAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesDeleteAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8641,26 +9489,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteAlias(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="name">A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteAliasAsync(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAliasAsync(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesDeleteAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesDeleteAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8672,27 +9524,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAliasAsync(st
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="type">A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesDeleteMapping<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDeleteMapping<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8704,27 +9558,29 @@ public ElasticsearchResponse<T> IndicesDeleteMapping<T>(string index, string typ
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="type">A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesDeleteMappingAsync<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteMappingAsync<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8737,26 +9593,30 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteMappingAsync<T>(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="type">A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDeleteMapping(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDeleteMapping(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8769,26 +9629,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteMapping(string inde
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="type">A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteMappingAsync(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteMappingAsync(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8799,26 +9663,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteMappingAsync(
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesDeleteTemplateForAll<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDeleteTemplateForAll<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8829,26 +9695,28 @@ public ElasticsearchResponse<T> IndicesDeleteTemplateForAll<T>(string name, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesDeleteTemplateForAllAsync<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteTemplateForAllAsync<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8860,25 +9728,29 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteTemplateForAllAsync<T>(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDeleteTemplateForAll(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDeleteTemplateForAll(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8890,25 +9762,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteTemplateForAll(stri
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteTemplateForAllAsync(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteTemplateForAllAsync(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -8920,27 +9796,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteTemplateForAl
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices.</param>
 		///<param name="name">A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesDeleteWarmer<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesDeleteWarmer<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8952,27 +9830,29 @@ public ElasticsearchResponse<T> IndicesDeleteWarmer<T>(string index, string name
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices.</param>
 		///<param name="name">A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesDeleteWarmerAsync<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesDeleteWarmerAsync<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -8985,26 +9865,30 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteWarmerAsync<T>(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices.</param>
 		///<param name="name">A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDeleteWarmer(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesDeleteWarmer(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9017,26 +9901,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteWarmer(string index
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices.</param>
 		///<param name="name">A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteWarmerAsync(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteWarmerAsync(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new DeleteWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new DeleteWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9047,26 +9935,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteWarmerAsync(s
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesExists<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExists<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexExistsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexExistsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9077,26 +9967,28 @@ public ElasticsearchResponse<T> IndicesExists<T>(string index, Func<IndexExistsR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesExistsAsync<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsAsync<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexExistsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexExistsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9108,25 +10000,29 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAsync<T>(string index, Func<I
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExists(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExists(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexExistsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexExistsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9138,25 +10034,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExists(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of indices to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsAsync(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAsync(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndexExistsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndexExistsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9167,26 +10067,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAsync(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesExistsAliasForAll<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsAliasForAll<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9197,26 +10099,28 @@ public ElasticsearchResponse<T> IndicesExistsAliasForAll<T>(string name, Func<In
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesExistsAliasForAllAsync<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsAliasForAllAsync<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9228,25 +10132,29 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasForAllAsync<T>(string na
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsAliasForAll(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsAliasForAll(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9258,25 +10166,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAliasForAll(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsAliasForAllAsync(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasForAllAsync(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9288,27 +10200,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasForAllAs
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesExistsAlias<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9320,27 +10234,29 @@ public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, string name,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesExistsAliasAsync<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9353,26 +10269,30 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, s
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsAlias(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9385,26 +10305,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsAliasAsync(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9415,26 +10339,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(st
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesExistsAlias<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9445,26 +10371,28 @@ public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, Func<Indices
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesExistsAliasAsync<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9476,25 +10404,29 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, F
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsAlias(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9506,25 +10438,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsAliasAsync(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9535,26 +10471,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(st
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesExistsTemplateForAll<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsTemplateForAll<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9565,26 +10503,28 @@ public ElasticsearchResponse<T> IndicesExistsTemplateForAll<T>(string name, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesExistsTemplateForAllAsync<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsTemplateForAllAsync<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9596,25 +10536,29 @@ public Task<ElasticsearchResponse<T>> IndicesExistsTemplateForAllAsync<T>(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsTemplateForAll(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsTemplateForAll(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9626,25 +10570,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsTemplateForAll(stri
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsTemplateForAllAsync(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTemplateForAllAsync(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9656,27 +10604,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTemplateForAl
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` to check the types across all indices</param>
 		///<param name="type">A comma-separated list of document types to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesExistsType<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesExistsType<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsTypeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsTypeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9688,27 +10638,29 @@ public ElasticsearchResponse<T> IndicesExistsType<T>(string index, string type,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` to check the types across all indices</param>
 		///<param name="type">A comma-separated list of document types to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesExistsTypeAsync<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesExistsTypeAsync<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsTypeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsTypeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9721,26 +10673,30 @@ public Task<ElasticsearchResponse<T>> IndicesExistsTypeAsync<T>(string index, st
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` to check the types across all indices</param>
 		///<param name="type">A comma-separated list of document types to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsType(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesExistsType(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsTypeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsTypeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9753,26 +10709,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsType(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` to check the types across all indices</param>
 		///<param name="type">A comma-separated list of document types to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsTypeAsync(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTypeAsync(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesExistsTypeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesExistsTypeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9782,25 +10742,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTypeAsync(str
 		///<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/indices-flush.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesFlushForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesFlushForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			var url = "_flush";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9810,25 +10772,27 @@ public ElasticsearchResponse<T> IndicesFlushForAll<T>(Func<FlushRequestParameter
 		///<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/indices-flush.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesFlushForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesFlushForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			var url = "_flush";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9839,24 +10803,28 @@ public Task<ElasticsearchResponse<T>> IndicesFlushForAllAsync<T>(Func<FlushReque
 		///<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/1.x/indices-flush.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesFlushForAll(Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesFlushForAll(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			var url = "_flush";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9867,24 +10835,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlushForAll(Func<FlushReq
 		///<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/1.x/indices-flush.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesFlushForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			var url = "_flush";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9895,26 +10867,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushForAllAsync(Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesFlush<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesFlush<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9925,26 +10899,28 @@ public ElasticsearchResponse<T> IndicesFlush<T>(string index, Func<FlushRequestP
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesFlushAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesFlushAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -9956,25 +10932,29 @@ public Task<ElasticsearchResponse<T>> IndicesFlushAsync<T>(string index, Func<Fl
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesFlush(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesFlush(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -9986,25 +10966,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlush(string index, Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesFlushAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10014,25 +10998,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushAsync(string i
 		///<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/indices-flush.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesFlushGetForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesFlushGetForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			var url = "_flush";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10042,25 +11028,27 @@ public ElasticsearchResponse<T> IndicesFlushGetForAll<T>(Func<FlushRequestParame
 		///<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/indices-flush.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesFlushGetForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesFlushGetForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			var url = "_flush";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10071,24 +11059,28 @@ public Task<ElasticsearchResponse<T>> IndicesFlushGetForAllAsync<T>(Func<FlushRe
 		///<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/1.x/indices-flush.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesFlushGetForAll(Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesFlushGetForAll(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			var url = "_flush";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10099,24 +11091,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlushGetForAll(Func<Flush
 		///<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/1.x/indices-flush.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesFlushGetForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			var url = "_flush";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10127,26 +11123,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetForAllAsync
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesFlushGet<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesFlushGet<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10157,26 +11155,28 @@ public ElasticsearchResponse<T> IndicesFlushGet<T>(string index, Func<FlushReque
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesFlushGetAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesFlushGetAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10188,25 +11188,29 @@ public Task<ElasticsearchResponse<T>> IndicesFlushGetAsync<T>(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesFlushGet(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesFlushGet(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10218,25 +11222,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlushGet(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesFlushGetAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_flush".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new FlushRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new FlushRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10246,25 +11254,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetAsync(strin
 		///<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/indices-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetAliasForAll<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_alias";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10274,25 +11284,27 @@ public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(Func<GetAliasesRequestP
 		///<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/indices-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetAliasForAllAsync<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_alias";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10303,24 +11315,28 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(Func<GetAlia
 		///<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/1.x/indices-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliasForAll(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_alias";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10331,24 +11347,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(Func<GetAl
 		///<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/1.x/indices-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasForAllAsync(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_alias";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10359,26 +11379,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetAliasForAll<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10389,26 +11411,28 @@ public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(string name, Func<GetAl
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetAliasForAllAsync<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10420,25 +11444,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(string name,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliasForAll(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10450,25 +11478,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(string nam
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasForAllAsync(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10480,27 +11512,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetAlias<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10512,27 +11546,29 @@ public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, string name, Fu
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetAliasAsync<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10545,26 +11581,30 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, stri
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAlias(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10577,26 +11617,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, st
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasAsync(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10607,26 +11651,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(strin
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetAlias<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10637,26 +11683,28 @@ public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, Func<GetAliases
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetAliasAsync<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10668,25 +11716,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAlias(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10698,25 +11750,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasAsync(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_alias".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10726,25 +11782,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(strin
 		///<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/indices-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetAliasesForAll<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_aliases";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10754,25 +11812,27 @@ public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(Func<IndicesGetAliase
 		///<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/indices-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetAliasesForAllAsync<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_aliases";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10783,24 +11843,28 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(Func<Indic
 		///<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/1.x/indices-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliasesForAll(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_aliases";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10811,24 +11875,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(Func<Ind
 		///<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/1.x/indices-aliases.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasesForAllAsync(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_aliases";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10839,26 +11907,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsy
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetAliases<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_aliases".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10869,26 +11939,28 @@ public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, Func<IndicesG
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetAliasesAsync<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_aliases".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10900,25 +11972,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliases(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_aliases".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10930,25 +12006,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasesAsync(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_aliases".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -10960,27 +12040,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(str
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetAliases<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_aliases/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -10992,27 +12074,29 @@ public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, string name,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetAliasesAsync<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_aliases/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11025,26 +12109,30 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, st
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliases(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_aliases/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11057,26 +12145,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasesAsync(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_aliases/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11087,26 +12179,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(str
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetAliasesForAll<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_aliases/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11117,26 +12211,28 @@ public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(string name, Func<Ind
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetAliasesForAllAsync<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_aliases/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11148,25 +12244,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(string nam
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliasesForAll(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_aliases/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11178,25 +12278,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(string n
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasesForAllAsync(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_aliases/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetAliasesRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetAliasesRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11207,26 +12311,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsy
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html</para>	
 	    ///</summary>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetFieldMappingForAll<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/field/{0}".F(Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11237,26 +12343,28 @@ public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string field, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html</para>	
 	    ///</summary>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetFieldMappingForAllAsync<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/field/{0}".F(Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11268,25 +12376,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(strin
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html</para>	
 	    ///</summary>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetFieldMappingForAll(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/field/{0}".F(Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11298,25 +12410,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(str
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html</para>	
 	    ///</summary>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetFieldMappingForAllAsync(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/field/{0}".F(Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11328,27 +12444,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForA
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetFieldMapping<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "{0}/_mapping/field/{1}".F(Encoded(index), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11360,27 +12478,29 @@ public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string f
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetFieldMappingAsync<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "{0}/_mapping/field/{1}".F(Encoded(index), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11393,26 +12513,30 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string inde
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetFieldMapping(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "{0}/_mapping/field/{1}".F(Encoded(index), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11425,26 +12549,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string in
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetFieldMappingAsync(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "{0}/_mapping/field/{1}".F(Encoded(index), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11456,27 +12584,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsyn
 	    ///</summary>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetFieldMappingForAll<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/{0}/field/{1}".F(Encoded(type), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11488,27 +12618,29 @@ public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string type, str
 	    ///</summary>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetFieldMappingForAllAsync<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/{0}/field/{1}".F(Encoded(type), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11521,26 +12653,30 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(strin
 	    ///</summary>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetFieldMappingForAll(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/{0}/field/{1}".F(Encoded(type), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11553,26 +12689,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(str
 	    ///</summary>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetFieldMappingForAllAsync(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "_mapping/{0}/field/{1}".F(Encoded(type), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11585,28 +12725,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForA
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetFieldMapping<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "{0}/_mapping/{1}/field/{2}".F(Encoded(index), Encoded(type), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11619,28 +12761,30 @@ public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string t
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetFieldMappingAsync<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "{0}/_mapping/{1}/field/{2}".F(Encoded(index), Encoded(type), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11654,27 +12798,31 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string inde
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetFieldMapping(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "{0}/_mapping/{1}/field/{2}".F(Encoded(index), Encoded(type), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11688,27 +12836,31 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string in
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetFieldMappingAsync(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			field.ThrowIfNullOrEmpty("field");
 			var url = "{0}/_mapping/{1}/field/{2}".F(Encoded(index), Encoded(type), Encoded(field));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesGetFieldMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesGetFieldMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11718,25 +12870,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsyn
 		///<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/indices-get-mapping.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetMappingForAll<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			var url = "_mapping";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11746,25 +12900,27 @@ public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(Func<GetMappingReques
 		///<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/indices-get-mapping.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetMappingForAllAsync<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			var url = "_mapping";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11775,24 +12931,28 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(Func<GetMa
 		///<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/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetMappingForAll(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			var url = "_mapping";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11803,24 +12963,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(Func<Get
 		///<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/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetMappingForAllAsync(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			var url = "_mapping";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11831,26 +12995,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsy
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetMapping<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mapping".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11861,26 +13027,28 @@ public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, Func<GetMappi
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetMappingAsync<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mapping".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11892,25 +13060,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetMapping(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mapping".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11922,25 +13094,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetMappingAsync(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mapping".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -11951,26 +13127,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(str
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetMappingForAll<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -11981,26 +13159,28 @@ public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(string type, Func<Get
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetMappingForAllAsync<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12012,25 +13192,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(string typ
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetMappingForAll(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12042,25 +13226,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(string t
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetMappingForAllAsync(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12072,27 +13260,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsy
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetMapping<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/_mapping/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12104,27 +13294,29 @@ public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, string type,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetMappingAsync<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/_mapping/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12137,26 +13329,30 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, st
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetMapping(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/_mapping/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12169,26 +13365,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetMappingAsync(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/_mapping/{1}".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12198,25 +13398,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(str
 		///<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/indices-get-mapping.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetSettingsForAll<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_settings";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12226,25 +13428,27 @@ public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(Func<GetIndexSetting
 		///<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/indices-get-mapping.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetSettingsForAllAsync<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_settings";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12255,24 +13459,28 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(Func<GetI
 		///<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/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetSettingsForAll(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_settings";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12283,24 +13491,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(Func<Ge
 		///<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/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetSettingsForAllAsync(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_settings";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12311,26 +13523,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAs
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetSettings<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12341,26 +13555,28 @@ public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, Func<GetInde
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetSettingsAsync<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12372,25 +13588,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, F
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetSettings(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12402,25 +13622,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetSettingsAsync(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12432,27 +13656,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(st
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetSettings<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_settings/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12464,27 +13690,29 @@ public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, string name,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetSettingsAsync<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_settings/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12497,26 +13725,30 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, s
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetSettings(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_settings/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12529,26 +13761,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetSettingsAsync(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_settings/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12559,26 +13795,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(st
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetSettingsForAll<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_settings/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12589,26 +13827,28 @@ public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(string name, Func<Ge
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetSettingsForAllAsync<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_settings/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12620,25 +13860,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(string na
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetSettingsForAll(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_settings/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12650,25 +13894,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetSettingsForAllAsync(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_settings/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetIndexSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetIndexSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12678,25 +13926,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAs
 		///<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/indices-templates.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetTemplateForAll<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
 		{
 			var url = "_template";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12706,25 +13956,27 @@ public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(Func<GetTemplateRequ
 		///<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/indices-templates.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetTemplateForAllAsync<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
 		{
 			var url = "_template";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12735,24 +13987,28 @@ public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(Func<GetT
 		///<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/1.x/indices-templates.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetTemplateForAll(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
 		{
 			var url = "_template";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12763,24 +14019,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(Func<Ge
 		///<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/1.x/indices-templates.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetTemplateForAllAsync(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
 		{
 			var url = "_template";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12791,26 +14051,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAs
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetTemplateForAll<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12821,26 +14083,28 @@ public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(string name, Func<Ge
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetTemplateForAllAsync<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12852,25 +14116,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(string na
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetTemplateForAll(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12882,25 +14150,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetTemplateForAllAsync(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12910,25 +14182,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAs
 		///<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/indices-warmers.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetWarmerForAll<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			var url = "_warmer";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12938,25 +14212,27 @@ public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(Func<GetWarmerRequestP
 		///<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/indices-warmers.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetWarmerForAllAsync<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			var url = "_warmer";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -12967,24 +14243,28 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(Func<GetWar
 		///<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/1.x/indices-warmers.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmerForAll(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			var url = "_warmer";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -12995,24 +14275,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(Func<GetW
 		///<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/1.x/indices-warmers.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerForAllAsync(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			var url = "_warmer";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13023,26 +14307,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsyn
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetWarmer<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_warmer".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13053,26 +14339,28 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, Func<GetWarmer
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetWarmerAsync<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_warmer".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13084,25 +14372,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, Fun
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmer(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_warmer".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13114,25 +14406,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, F
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerAsync(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_warmer".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13144,27 +14440,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetWarmer<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13176,27 +14474,29 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string name, F
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetWarmerAsync<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13209,26 +14509,30 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, str
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmer(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13241,26 +14545,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, s
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerAsync(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13271,26 +14579,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetWarmerForAll<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13301,26 +14611,28 @@ public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(string name, Func<GetW
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetWarmerForAllAsync<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13332,25 +14644,29 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(string name
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmerForAll(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13362,25 +14678,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(string na
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 	    ///</summary>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerForAllAsync(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13393,28 +14713,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsyn
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesGetWarmer<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13427,28 +14749,30 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string type, s
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesGetWarmerAsync<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13462,27 +14786,31 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, str
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmer(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13496,27 +14824,31 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, s
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerAsync(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new GetWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new GetWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13527,26 +14859,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesOpen<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOpen<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_open".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OpenIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OpenIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13557,26 +14891,28 @@ public ElasticsearchResponse<T> IndicesOpen<T>(string index, Func<OpenIndexReque
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesOpenAsync<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOpenAsync<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_open".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OpenIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OpenIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13588,25 +14924,29 @@ public Task<ElasticsearchResponse<T>> IndicesOpenAsync<T>(string index, Func<Ope
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOpen(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOpen(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_open".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OpenIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OpenIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13618,25 +14958,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOpen(string index, Func<O
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOpenAsync(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOpenAsync(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_open".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OpenIndexRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OpenIndexRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13646,25 +14990,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOpenAsync(string in
 		///<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/indices-optimize.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesOptimizeForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOptimizeForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			var url = "_optimize";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13674,25 +15020,27 @@ public ElasticsearchResponse<T> IndicesOptimizeForAll<T>(Func<OptimizeRequestPar
 		///<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/indices-optimize.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesOptimizeForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOptimizeForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			var url = "_optimize";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13703,24 +15051,28 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeForAllAsync<T>(Func<Optimiz
 		///<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/1.x/indices-optimize.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOptimizeForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			var url = "_optimize";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13731,24 +15083,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeForAll(Func<Optim
 		///<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/1.x/indices-optimize.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOptimizeForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			var url = "_optimize";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13759,26 +15115,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeForAllAsync
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesOptimize<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOptimize<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13789,26 +15147,28 @@ public ElasticsearchResponse<T> IndicesOptimize<T>(string index, Func<OptimizeRe
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesOptimizeAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOptimizeAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13820,25 +15180,29 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeAsync<T>(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOptimize(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOptimize(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13850,25 +15214,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimize(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOptimizeAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13878,25 +15246,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeAsync(strin
 		///<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/indices-optimize.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesOptimizeGetForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOptimizeGetForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			var url = "_optimize";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13906,25 +15276,27 @@ public ElasticsearchResponse<T> IndicesOptimizeGetForAll<T>(Func<OptimizeRequest
 		///<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/indices-optimize.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesOptimizeGetForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOptimizeGetForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			var url = "_optimize";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -13935,24 +15307,28 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeGetForAllAsync<T>(Func<Opti
 		///<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/1.x/indices-optimize.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOptimizeGetForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGetForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			var url = "_optimize";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13963,24 +15339,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGetForAll(Func<Op
 		///<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/1.x/indices-optimize.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOptimizeGetForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			var url = "_optimize";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -13991,26 +15371,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetForAllAs
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesOptimizeGet<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesOptimizeGet<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14021,26 +15403,28 @@ public ElasticsearchResponse<T> IndicesOptimizeGet<T>(string index, Func<Optimiz
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesOptimizeGetAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesOptimizeGetAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14052,25 +15436,29 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeGetAsync<T>(string index, F
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOptimizeGet(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGet(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14082,25 +15470,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGet(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOptimizeGetAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_optimize".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new OptimizeRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new OptimizeRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14113,27 +15505,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetAsync(st
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutAlias<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutAlias<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14146,27 +15540,29 @@ public ElasticsearchResponse<T> IndicesPutAlias<T>(string index, string name, ob
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutAliasAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutAliasAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14180,26 +15576,30 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasAsync<T>(string index, stri
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutAlias(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutAlias(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14213,26 +15613,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAlias(string index, st
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutAliasAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14244,26 +15648,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasAsync(strin
 	    ///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutAliasForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutAliasForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14275,26 +15681,28 @@ public ElasticsearchResponse<T> IndicesPutAliasForAll<T>(string name, object bod
 	    ///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutAliasForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutAliasForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14307,25 +15715,29 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasForAllAsync<T>(string name,
 	    ///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutAliasForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14338,25 +15750,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasForAll(string nam
 	    ///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutAliasForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14369,27 +15785,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasForAllAsync
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutAliasPost<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutAliasPost<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14402,27 +15820,29 @@ public ElasticsearchResponse<T> IndicesPutAliasPost<T>(string index, string name
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutAliasPostAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutAliasPostAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14436,26 +15856,30 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasPostAsync<T>(string index,
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutAliasPost(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPost(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14469,26 +15893,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPost(string index
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutAliasPostAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_alias/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14500,26 +15928,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostAsync(s
 	    ///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutAliasPostForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutAliasPostForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14531,26 +15961,28 @@ public ElasticsearchResponse<T> IndicesPutAliasPostForAll<T>(string name, object
 	    ///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutAliasPostForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutAliasPostForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14563,25 +15995,29 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasPostForAllAsync<T>(string n
 	    ///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutAliasPostForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPostForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14594,25 +16030,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPostForAll(string
 	    ///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutAliasPostForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_alias/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesPutAliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesPutAliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14625,27 +16065,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostForAllA
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutMapping<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutMapping<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14658,27 +16100,29 @@ public ElasticsearchResponse<T> IndicesPutMapping<T>(string index, string type,
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutMappingAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutMappingAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14692,26 +16136,30 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingAsync<T>(string index, st
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutMapping(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutMapping(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14725,26 +16173,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMapping(string index,
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutMappingAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14756,26 +16208,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingAsync(str
 	    ///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutMappingForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutMappingForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14787,26 +16241,28 @@ public ElasticsearchResponse<T> IndicesPutMappingForAll<T>(string type, object b
 	    ///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutMappingForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutMappingForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14819,25 +16275,29 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingForAllAsync<T>(string typ
 	    ///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutMappingForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14850,25 +16310,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingForAll(string t
 	    ///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutMappingForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14881,27 +16345,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingForAllAsy
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutMappingPost<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutMappingPost<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14914,27 +16380,29 @@ public ElasticsearchResponse<T> IndicesPutMappingPost<T>(string index, string ty
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutMappingPostAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutMappingPostAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -14948,26 +16416,30 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingPostAsync<T>(string index
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutMappingPost(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPost(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -14981,26 +16453,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPost(string ind
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutMappingPostAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mapping".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15012,26 +16488,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostAsync
 	    ///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutMappingPostForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutMappingPostForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15043,26 +16521,28 @@ public ElasticsearchResponse<T> IndicesPutMappingPostForAll<T>(string type, obje
 	    ///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutMappingPostForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutMappingPostForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15075,25 +16555,29 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingPostForAllAsync<T>(string
 	    ///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutMappingPostForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPostForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15106,25 +16590,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPostForAll(stri
 	    ///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutMappingPostForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null)
 		{
 			type.ThrowIfNullOrEmpty("type");
 			var url = "_mapping/{0}".F(Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutMappingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutMappingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15135,25 +16623,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostForAl
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html</para>	
 	    ///</summary>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutSettingsForAll<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutSettingsForAll<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_settings".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15164,25 +16654,27 @@ public ElasticsearchResponse<T> IndicesPutSettingsForAll<T>(object body, Func<Up
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html</para>	
 	    ///</summary>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutSettingsForAllAsync<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutSettingsForAllAsync<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_settings".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15194,24 +16686,28 @@ public Task<ElasticsearchResponse<T>> IndicesPutSettingsForAllAsync<T>(object bo
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html</para>	
 	    ///</summary>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutSettingsForAll(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutSettingsForAll(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_settings".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15223,24 +16719,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutSettingsForAll(object
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html</para>	
 	    ///</summary>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutSettingsForAllAsync(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsForAllAsync(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null)
 		{
 			var url = "_settings".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15252,26 +16752,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsForAllAs
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutSettings<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutSettings<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15283,26 +16785,28 @@ public ElasticsearchResponse<T> IndicesPutSettings<T>(string index, object body,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutSettingsAsync<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutSettingsAsync<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15315,25 +16819,29 @@ public Task<ElasticsearchResponse<T>> IndicesPutSettingsAsync<T>(string index, o
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutSettings(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutSettings(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15346,25 +16854,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutSettings(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutSettingsAsync(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsAsync(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_settings".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateSettingsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateSettingsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15376,26 +16888,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsAsync(st
 	    ///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutTemplateForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutTemplateForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15407,26 +16921,28 @@ public ElasticsearchResponse<T> IndicesPutTemplateForAll<T>(string name, object
 	    ///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutTemplateForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutTemplateForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15439,25 +16955,29 @@ public Task<ElasticsearchResponse<T>> IndicesPutTemplateForAllAsync<T>(string na
 	    ///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutTemplateForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplateForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15470,25 +16990,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplateForAll(string
 	    ///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutTemplateForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplateForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15500,26 +17024,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplateForAllAs
 	    ///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutTemplatePostForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutTemplatePostForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15531,26 +17057,28 @@ public ElasticsearchResponse<T> IndicesPutTemplatePostForAll<T>(string name, obj
 	    ///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutTemplatePostForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutTemplatePostForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15563,25 +17091,29 @@ public Task<ElasticsearchResponse<T>> IndicesPutTemplatePostForAllAsync<T>(strin
 	    ///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutTemplatePostForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplatePostForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15594,25 +17126,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplatePostForAll(str
 	    ///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutTemplatePostForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplatePostForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_template/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutTemplateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutTemplateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15624,26 +17160,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplatePostForA
 	    ///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutWarmerForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmerForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15655,26 +17193,28 @@ public ElasticsearchResponse<T> IndicesPutWarmerForAll<T>(string name, object bo
 	    ///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutWarmerForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15687,25 +17227,29 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerForAllAsync<T>(string name
 	    ///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmerForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15718,25 +17262,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerForAll(string na
 	    ///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15749,27 +17297,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerForAllAsyn
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutWarmer<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15782,27 +17332,29 @@ public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string name, o
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutWarmerAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15816,26 +17368,30 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, str
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmer(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15849,26 +17405,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, s
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15882,28 +17442,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(stri
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutWarmer<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15917,28 +17479,30 @@ public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string type, s
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutWarmerAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -15953,27 +17517,31 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, str
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmer(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -15988,27 +17556,31 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, s
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16020,26 +17592,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(stri
 	    ///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutWarmerPostForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmerPostForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16051,26 +17625,28 @@ public ElasticsearchResponse<T> IndicesPutWarmerPostForAll<T>(string name, objec
 	    ///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutWarmerPostForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16083,25 +17659,29 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostForAllAsync<T>(string
 	    ///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmerPostForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPostForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16114,25 +17694,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPostForAll(strin
 	    ///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerPostForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_warmer/{0}".F(Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16145,27 +17729,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostForAll
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutWarmerPost<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16178,27 +17764,29 @@ public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string nam
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutWarmerPostAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16212,26 +17800,30 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index,
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmerPost(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16245,26 +17837,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string inde
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerPostAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/_warmer/{1}".F(Encoded(index), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16278,28 +17874,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesPutWarmerPost<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16313,28 +17911,30 @@ public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string typ
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesPutWarmerPostAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16349,27 +17949,31 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index,
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmerPost(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16384,27 +17988,31 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string inde
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerPostAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			name.ThrowIfNullOrEmpty("name");
 			var url = "{0}/{1}/_warmer/{2}".F(Encoded(index), Encoded(type), Encoded(name));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PutWarmerRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PutWarmerRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16414,25 +18022,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(
 		///<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/indices-refresh.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesRefreshForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesRefreshForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			var url = "_refresh";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16442,25 +18052,27 @@ public ElasticsearchResponse<T> IndicesRefreshForAll<T>(Func<RefreshRequestParam
 		///<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/indices-refresh.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesRefreshForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesRefreshForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			var url = "_refresh";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16471,24 +18083,28 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshForAllAsync<T>(Func<RefreshR
 		///<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/1.x/indices-refresh.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesRefreshForAll(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesRefreshForAll(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			var url = "_refresh";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16499,24 +18115,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefreshForAll(Func<Refres
 		///<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/1.x/indices-refresh.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesRefreshForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			var url = "_refresh";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16527,26 +18147,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshForAllAsync(
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesRefresh<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesRefresh<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16557,26 +18179,28 @@ public ElasticsearchResponse<T> IndicesRefresh<T>(string index, Func<RefreshRequ
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesRefreshAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesRefreshAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16588,25 +18212,29 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshAsync<T>(string index, Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesRefresh(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesRefresh(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16618,25 +18246,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefresh(string index, Fun
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesRefreshAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16646,25 +18278,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshAsync(string
 		///<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/indices-refresh.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesRefreshGetForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesRefreshGetForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			var url = "_refresh";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16674,25 +18308,27 @@ public ElasticsearchResponse<T> IndicesRefreshGetForAll<T>(Func<RefreshRequestPa
 		///<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/indices-refresh.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesRefreshGetForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesRefreshGetForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			var url = "_refresh";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16703,24 +18339,28 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshGetForAllAsync<T>(Func<Refre
 		///<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/1.x/indices-refresh.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesRefreshGetForAll(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGetForAll(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			var url = "_refresh";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16731,24 +18371,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGetForAll(Func<Ref
 		///<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/1.x/indices-refresh.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesRefreshGetForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			var url = "_refresh";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16759,26 +18403,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetForAllAsy
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesRefreshGet<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesRefreshGet<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16789,26 +18435,28 @@ public ElasticsearchResponse<T> IndicesRefreshGet<T>(string index, Func<RefreshR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesRefreshGetAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesRefreshGetAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16820,25 +18468,29 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshGetAsync<T>(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesRefreshGet(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGet(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16850,25 +18502,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGet(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesRefreshGetAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_refresh".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new RefreshRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new RefreshRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16878,25 +18534,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetAsync(str
 		///<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/indices-segments.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesSegmentsForAll<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesSegmentsForAll<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null)
 		{
 			var url = "_segments";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SegmentsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SegmentsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16906,25 +18564,27 @@ public ElasticsearchResponse<T> IndicesSegmentsForAll<T>(Func<SegmentsRequestPar
 		///<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/indices-segments.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesSegmentsForAllAsync<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesSegmentsForAllAsync<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null)
 		{
 			var url = "_segments";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SegmentsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SegmentsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -16935,24 +18595,28 @@ public Task<ElasticsearchResponse<T>> IndicesSegmentsForAllAsync<T>(Func<Segment
 		///<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/1.x/indices-segments.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesSegmentsForAll(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesSegmentsForAll(Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null)
 		{
 			var url = "_segments";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SegmentsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SegmentsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16963,24 +18627,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSegmentsForAll(Func<Segme
 		///<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/1.x/indices-segments.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesSegmentsForAllAsync(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsForAllAsync(Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null)
 		{
 			var url = "_segments";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SegmentsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SegmentsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -16991,26 +18659,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsForAllAsync
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesSegments<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesSegments<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_segments".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SegmentsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SegmentsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17021,26 +18691,28 @@ public ElasticsearchResponse<T> IndicesSegments<T>(string index, Func<SegmentsRe
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesSegmentsAsync<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesSegmentsAsync<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_segments".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SegmentsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SegmentsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17052,25 +18724,29 @@ public Task<ElasticsearchResponse<T>> IndicesSegmentsAsync<T>(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesSegments(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesSegments(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_segments".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SegmentsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SegmentsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17082,25 +18758,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSegments(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesSegmentsAsync(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsAsync(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_segments".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SegmentsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SegmentsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17110,25 +18790,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsAsync(strin
 		///<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/indices-gateway-snapshot.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesSnapshotIndexForAll<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesSnapshotIndexForAll<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null)
 		{
 			var url = "_gateway/snapshot";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17138,25 +18820,27 @@ public ElasticsearchResponse<T> IndicesSnapshotIndexForAll<T>(Func<SnapshotReque
 		///<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/indices-gateway-snapshot.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesSnapshotIndexForAllAsync<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexForAllAsync<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null)
 		{
 			var url = "_gateway/snapshot";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17167,24 +18851,28 @@ public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexForAllAsync<T>(Func<Sn
 		///<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/1.x/indices-gateway-snapshot.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesSnapshotIndexForAll(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndexForAll(Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null)
 		{
 			var url = "_gateway/snapshot";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17195,24 +18883,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndexForAll(Func<
 		///<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/1.x/indices-gateway-snapshot.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesSnapshotIndexForAllAsync(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexForAllAsync(Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null)
 		{
 			var url = "_gateway/snapshot";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17223,26 +18915,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexForAll
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesSnapshotIndex<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesSnapshotIndex<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_gateway/snapshot".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17253,26 +18947,28 @@ public ElasticsearchResponse<T> IndicesSnapshotIndex<T>(string index, Func<Snaps
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesSnapshotIndexAsync<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexAsync<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_gateway/snapshot".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17284,25 +18980,29 @@ public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexAsync<T>(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesSnapshotIndex(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndex(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_gateway/snapshot".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17314,25 +19014,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndex(string inde
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesSnapshotIndexAsync(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexAsync(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_gateway/snapshot".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17342,25 +19046,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexAsync(
 		///<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/indices-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesStatsForAll<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStatsForAll<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17370,25 +19076,27 @@ public ElasticsearchResponse<T> IndicesStatsForAll<T>(Func<IndicesStatsRequestPa
 		///<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/indices-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesStatsForAllAsync<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17399,24 +19107,28 @@ public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(Func<IndicesSta
 		///<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/1.x/indices-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStatsForAll(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17427,24 +19139,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(Func<IndicesS
 		///<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/1.x/indices-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatsForAllAsync(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17455,26 +19171,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesStatsForAll<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStatsForAll<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_stats/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17485,26 +19203,28 @@ public ElasticsearchResponse<T> IndicesStatsForAll<T>(string metric, Func<Indice
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesStatsForAllAsync<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_stats/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17516,25 +19236,29 @@ public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(string metric,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStatsForAll(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_stats/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17546,25 +19270,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(string metric
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatsForAllAsync(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_stats/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17575,26 +19303,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(st
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesStats<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStats<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_stats".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17605,26 +19335,28 @@ public ElasticsearchResponse<T> IndicesStats<T>(string index, Func<IndicesStatsR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesStatsAsync<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_stats".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17636,25 +19368,29 @@ public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, Func<In
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStats(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_stats".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17666,25 +19402,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatsAsync(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_stats".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17696,27 +19436,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string i
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesStats<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "{0}/_stats/{1}".F(Encoded(index), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17728,27 +19470,29 @@ public ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Fun
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesStatsAsync<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "{0}/_stats/{1}".F(Encoded(index), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17761,26 +19505,30 @@ public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, string
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStats(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "{0}/_stats/{1}".F(Encoded(index), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17793,26 +19541,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, strin
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatsAsync(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "{0}/_stats/{1}".F(Encoded(index), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17822,25 +19574,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string i
 		///<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/indices-status.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesStatusForAll<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStatusForAll<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null)
 		{
 			var url = "_status";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatusRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatusRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17850,25 +19604,27 @@ public ElasticsearchResponse<T> IndicesStatusForAll<T>(Func<IndicesStatusRequest
 		///<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/indices-status.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesStatusForAllAsync<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatusForAllAsync<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null)
 		{
 			var url = "_status";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatusRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatusRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17879,24 +19635,28 @@ public Task<ElasticsearchResponse<T>> IndicesStatusForAllAsync<T>(Func<IndicesSt
 		///<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/1.x/indices-status.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStatusForAll(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStatusForAll(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null)
 		{
 			var url = "_status";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatusRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatusRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17907,24 +19667,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatusForAll(Func<Indices
 		///<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/1.x/indices-status.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatusForAllAsync(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusForAllAsync(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null)
 		{
 			var url = "_status";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatusRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatusRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -17935,26 +19699,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusForAllAsync(F
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesStatus<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesStatus<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_status".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatusRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatusRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17965,26 +19731,28 @@ public ElasticsearchResponse<T> IndicesStatus<T>(string index, Func<IndicesStatu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesStatusAsync<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesStatusAsync<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_status".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatusRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatusRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -17996,25 +19764,29 @@ public Task<ElasticsearchResponse<T>> IndicesStatusAsync<T>(string index, Func<I
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStatus(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesStatus(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_status".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatusRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatusRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18026,25 +19798,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatus(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatusAsync(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusAsync(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_status".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new IndicesStatusRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new IndicesStatusRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18055,25 +19831,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusAsync(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="body">The definition of `actions` to perform</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesUpdateAliasesForAll<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesUpdateAliasesForAll<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> requestParameters = null)
 		{
 			var url = "_aliases".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18084,25 +19862,27 @@ public ElasticsearchResponse<T> IndicesUpdateAliasesForAll<T>(object body, Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="body">The definition of `actions` to perform</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesUpdateAliasesForAllAsync<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesUpdateAliasesForAllAsync<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> requestParameters = null)
 		{
 			var url = "_aliases".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18114,24 +19894,28 @@ public Task<ElasticsearchResponse<T>> IndicesUpdateAliasesForAllAsync<T>(object
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="body">The definition of `actions` to perform</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesUpdateAliasesForAll(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesUpdateAliasesForAll(object body, Func<AliasRequestParameters, AliasRequestParameters> requestParameters = null)
 		{
 			var url = "_aliases".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18143,24 +19927,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesUpdateAliasesForAll(objec
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 	    ///</summary>
 		///<param name="body">The definition of `actions` to perform</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesUpdateAliasesForAllAsync(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesUpdateAliasesForAllAsync(object body, Func<AliasRequestParameters, AliasRequestParameters> requestParameters = null)
 		{
 			var url = "_aliases".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new AliasRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new AliasRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18170,25 +19958,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesUpdateAliasesForAll
 		///<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/search-validate.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesValidateQueryGetForAll<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQueryGetForAll<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			var url = "_validate/query";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18198,25 +19988,27 @@ public ElasticsearchResponse<T> IndicesValidateQueryGetForAll<T>(Func<ValidateQu
 		///<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/search-validate.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesValidateQueryGetForAllAsync<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetForAllAsync<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			var url = "_validate/query";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18227,24 +20019,28 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetForAllAsync<T>(Func
 		///<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/1.x/search-validate.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQueryGetForAll(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGetForAll(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			var url = "_validate/query";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18255,24 +20051,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGetForAll(Fu
 		///<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/1.x/search-validate.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryGetForAllAsync(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetForAllAsync(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			var url = "_validate/query";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18283,26 +20083,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetFor
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesValidateQueryGet<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18313,26 +20115,28 @@ public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, Func<Va
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesValidateQueryGetAsync<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18344,25 +20148,29 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string ind
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQueryGet(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18374,25 +20182,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string i
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryGetAsync(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18404,27 +20216,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsy
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesValidateQueryGet<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_validate/query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18436,27 +20250,29 @@ public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, string
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesValidateQueryGetAsync<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_validate/query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18469,26 +20285,30 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string ind
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQueryGet(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_validate/query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18501,26 +20321,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string i
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryGetAsync(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_validate/query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18531,25 +20355,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsy
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 	    ///</summary>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesValidateQueryForAll<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQueryForAll<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			var url = "_validate/query".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18560,25 +20386,27 @@ public ElasticsearchResponse<T> IndicesValidateQueryForAll<T>(object body, Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 	    ///</summary>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesValidateQueryForAllAsync<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryForAllAsync<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			var url = "_validate/query".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18590,24 +20418,28 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryForAllAsync<T>(object
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 	    ///</summary>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQueryForAll(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryForAll(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			var url = "_validate/query".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18619,24 +20451,28 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryForAll(objec
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 	    ///</summary>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryForAllAsync(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryForAllAsync(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			var url = "_validate/query".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18648,26 +20484,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryForAll
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesValidateQuery<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18679,26 +20517,28 @@ public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, object bod
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesValidateQueryAsync<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18711,25 +20551,29 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQuery(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18742,25 +20586,29 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string inde
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryAsync(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_validate/query".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18773,27 +20621,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> IndicesValidateQuery<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_validate/query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18806,27 +20656,29 @@ public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, string typ
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> IndicesValidateQueryAsync<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_validate/query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18840,26 +20692,30 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index,
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQuery(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_validate/query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18873,26 +20729,30 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string inde
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryAsync(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_validate/query".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ValidateQueryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ValidateQueryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18902,25 +20762,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 	    ///<para>See also: http://www.elasticsearch.org/guide/</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Info<T>(Func<InfoRequestParameters, InfoRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Info<T>(Func<InfoRequestParameters, InfoRequestParameters> requestParameters = null)
 		{
 			var url = "";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new InfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new InfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18930,25 +20792,27 @@ public ElasticsearchResponse<T> Info<T>(Func<InfoRequestParameters, InfoRequestP
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 	    ///<para>See also: http://www.elasticsearch.org/guide/</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> InfoAsync<T>(Func<InfoRequestParameters, InfoRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> InfoAsync<T>(Func<InfoRequestParameters, InfoRequestParameters> requestParameters = null)
 		{
 			var url = "";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new InfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new InfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -18959,24 +20823,28 @@ public Task<ElasticsearchResponse<T>> InfoAsync<T>(Func<InfoRequestParameters, I
 		///<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/</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Info(Func<InfoRequestParameters, InfoRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Info(Func<InfoRequestParameters, InfoRequestParameters> requestParameters = null)
 		{
 			var url = "";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new InfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new InfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -18987,24 +20855,28 @@ public ElasticsearchResponse<DynamicDictionary> Info(Func<InfoRequestParameters,
 		///<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/</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> InfoAsync(Func<InfoRequestParameters, InfoRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> InfoAsync(Func<InfoRequestParameters, InfoRequestParameters> requestParameters = null)
 		{
 			var url = "";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new InfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new InfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19014,25 +20886,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> InfoAsync(Func<InfoRequest
 		///<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-multi-get.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MgetGet<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MgetGet<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			var url = "_mget";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19042,25 +20916,27 @@ public ElasticsearchResponse<T> MgetGet<T>(Func<MultiGetRequestParameters, Multi
 		///<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-multi-get.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MgetGetAsync<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			var url = "_mget";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19071,24 +20947,28 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(Func<MultiGetRequestParame
 		///<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/1.x/docs-multi-get.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MgetGet(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MgetGet(Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			var url = "_mget";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19099,24 +20979,28 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(Func<MultiGetRequestPara
 		///<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/1.x/docs-multi-get.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetGetAsync(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			var url = "_mget";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19127,26 +21011,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(Func<MultiGet
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MgetGet<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MgetGet<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19157,26 +21043,28 @@ public ElasticsearchResponse<T> MgetGet<T>(string index, Func<MultiGetRequestPar
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MgetGetAsync<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19188,25 +21076,29 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, Func<MultiGe
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MgetGet(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19218,25 +21110,29 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, Func<Multi
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 	    ///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetGetAsync(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19248,27 +21144,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index,
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MgetGet<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MgetGet<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mget".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19280,27 +21178,29 @@ public ElasticsearchResponse<T> MgetGet<T>(string index, string type, Func<Multi
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MgetGetAsync<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mget".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19313,26 +21213,30 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, string type,
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MgetGet(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mget".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19345,26 +21249,30 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, string typ
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetGetAsync(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mget".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19375,25 +21283,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 	    ///</summary>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mget<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mget<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			var url = "_mget".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19404,25 +21314,27 @@ public ElasticsearchResponse<T> Mget<T>(object body, Func<MultiGetRequestParamet
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 	    ///</summary>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MgetAsync<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetAsync<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			var url = "_mget".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19434,24 +21346,28 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(object body, Func<MultiGetReq
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 	    ///</summary>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mget(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mget(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			var url = "_mget".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19463,24 +21379,28 @@ public ElasticsearchResponse<DynamicDictionary> Mget(object body, Func<MultiGetR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 	    ///</summary>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetAsync(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			var url = "_mget".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19492,26 +21412,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(object body, Fun
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mget<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mget<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19523,26 +21445,28 @@ public ElasticsearchResponse<T> Mget<T>(string index, object body, Func<MultiGet
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MgetAsync<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19555,25 +21479,29 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, object body, Fu
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mget(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mget(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19586,25 +21514,29 @@ public ElasticsearchResponse<DynamicDictionary> Mget(string index, object body,
 	    ///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetAsync(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mget".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19617,27 +21549,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, ob
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mget<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mget<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mget".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19650,27 +21584,29 @@ public ElasticsearchResponse<T> Mget<T>(string index, string type, object body,
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MgetAsync<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mget".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19684,26 +21620,30 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, string type, ob
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mget(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mget(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mget".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19717,26 +21657,30 @@ public ElasticsearchResponse<DynamicDictionary> Mget(string index, string type,
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetAsync(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mget".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19749,28 +21693,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, st
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MltGet<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MltGet<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_mlt".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MoreLikeThisRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MoreLikeThisRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19783,28 +21729,30 @@ public ElasticsearchResponse<T> MltGet<T>(string index, string type, string id,
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MltGetAsync<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MltGetAsync<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_mlt".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MoreLikeThisRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MoreLikeThisRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19818,27 +21766,31 @@ public Task<ElasticsearchResponse<T>> MltGetAsync<T>(string index, string type,
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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> MltGet(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MltGet(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_mlt".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MoreLikeThisRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MoreLikeThisRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19852,27 +21804,31 @@ public ElasticsearchResponse<DynamicDictionary> MltGet(string index, string type
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MltGetAsync(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MltGetAsync(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_mlt".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MoreLikeThisRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MoreLikeThisRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19886,28 +21842,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MltGetAsync(string index,
 		///<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="body">A specific search request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mlt<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mlt<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_mlt".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MoreLikeThisRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MoreLikeThisRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19921,28 +21879,30 @@ public ElasticsearchResponse<T> Mlt<T>(string index, string type, string id, obj
 		///<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="body">A specific search request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MltAsync<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MltAsync<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_mlt".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MoreLikeThisRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MoreLikeThisRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -19957,27 +21917,31 @@ public Task<ElasticsearchResponse<T>> MltAsync<T>(string index, string type, str
 		///<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="body">A specific search request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mlt(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mlt(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_mlt".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MoreLikeThisRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MoreLikeThisRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -19992,27 +21956,31 @@ public ElasticsearchResponse<DynamicDictionary> Mlt(string index, string type, s
 		///<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="body">A specific search request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MltAsync(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MltAsync(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_mlt".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MoreLikeThisRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MoreLikeThisRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20022,25 +21990,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MltAsync(string index, str
 		///<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/search-percolate.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MpercolateGet<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MpercolateGet<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			var url = "_mpercolate";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20050,25 +22020,27 @@ public ElasticsearchResponse<T> MpercolateGet<T>(Func<MpercolateRequestParameter
 		///<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/search-percolate.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MpercolateGetAsync<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			var url = "_mpercolate";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20079,24 +22051,28 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(Func<MpercolateReque
 		///<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/1.x/search-percolate.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MpercolateGet(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MpercolateGet(Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			var url = "_mpercolate";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20107,24 +22083,28 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(Func<MpercolateReq
 		///<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/1.x/search-percolate.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateGetAsync(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			var url = "_mpercolate";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20135,26 +22115,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(Func<Mp
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MpercolateGet<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MpercolateGet<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20165,26 +22147,28 @@ public ElasticsearchResponse<T> MpercolateGet<T>(string index, Func<MpercolateRe
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MpercolateGetAsync<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20196,25 +22180,29 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, Func<M
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MpercolateGet(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20226,25 +22214,29 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateGetAsync(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20256,27 +22248,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MpercolateGet<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MpercolateGet<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mpercolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20288,27 +22282,29 @@ public ElasticsearchResponse<T> MpercolateGet<T>(string index, string type, Func
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MpercolateGetAsync<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mpercolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20321,26 +22317,30 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MpercolateGet(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mpercolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20353,26 +22353,30 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, stri
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateGetAsync(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mpercolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20383,25 +22387,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 	    ///</summary>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mpercolate<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mpercolate<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			var url = "_mpercolate".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20412,25 +22418,27 @@ public ElasticsearchResponse<T> Mpercolate<T>(object body, Func<MpercolateReques
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 	    ///</summary>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MpercolateAsync<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			var url = "_mpercolate".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20442,24 +22450,28 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(object body, Func<Mperc
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 	    ///</summary>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mpercolate(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mpercolate(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			var url = "_mpercolate".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20471,24 +22483,28 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(object body, Func<Mpe
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 	    ///</summary>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateAsync(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			var url = "_mpercolate".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20500,26 +22516,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(object bod
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mpercolate<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mpercolate<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20531,26 +22549,28 @@ public ElasticsearchResponse<T> Mpercolate<T>(string index, object body, Func<Mp
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MpercolateAsync<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20563,25 +22583,29 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, object bo
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mpercolate(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20594,25 +22618,29 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, object
 	    ///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateAsync(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mpercolate".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20625,27 +22653,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string ind
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mpercolate<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mpercolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20658,27 +22688,29 @@ public ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MpercolateAsync<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mpercolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20692,26 +22724,30 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, string ty
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mpercolate(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mpercolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20725,26 +22761,30 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, string
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateAsync(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mpercolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MpercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MpercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20754,25 +22794,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string ind
 		///<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/search-multi-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MsearchGet<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MsearchGet<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			var url = "_msearch";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20782,25 +22824,27 @@ public ElasticsearchResponse<T> MsearchGet<T>(Func<MultiSearchRequestParameters,
 		///<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/search-multi-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MsearchGetAsync<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			var url = "_msearch";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20811,24 +22855,28 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(Func<MultiSearchRequest
 		///<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/1.x/search-multi-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MsearchGet(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MsearchGet(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			var url = "_msearch";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20839,24 +22887,28 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(Func<MultiSearchReque
 		///<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/1.x/search-multi-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchGetAsync(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			var url = "_msearch";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20867,26 +22919,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(Func<Multi
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MsearchGet<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MsearchGet<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20897,26 +22951,28 @@ public ElasticsearchResponse<T> MsearchGet<T>(string index, Func<MultiSearchRequ
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MsearchGetAsync<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -20928,25 +22984,29 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, Func<Mult
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MsearchGet(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20958,25 +23018,29 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, Func<Mu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchGetAsync(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -20988,27 +23052,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string ind
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MsearchGet<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_msearch".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21020,27 +23086,29 @@ public ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<Mu
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MsearchGetAsync<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_msearch".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21053,26 +23121,30 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, string ty
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MsearchGet(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_msearch".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21085,26 +23157,30 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, string
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchGetAsync(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_msearch".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21115,25 +23191,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string ind
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 	    ///</summary>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Msearch<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Msearch<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			var url = "_msearch".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21144,25 +23222,27 @@ public ElasticsearchResponse<T> Msearch<T>(object body, Func<MultiSearchRequestP
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 	    ///</summary>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MsearchAsync<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchAsync<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			var url = "_msearch".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21174,24 +23254,28 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(object body, Func<MultiSea
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 	    ///</summary>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Msearch(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Msearch(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			var url = "_msearch".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21203,24 +23287,28 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(object body, Func<MultiS
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 	    ///</summary>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchAsync(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			var url = "_msearch".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21232,26 +23320,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(object body,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Msearch<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Msearch<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21263,26 +23353,28 @@ public ElasticsearchResponse<T> Msearch<T>(string index, object body, Func<Multi
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MsearchAsync<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21295,25 +23387,29 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, object body,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Msearch(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Msearch(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21326,25 +23422,29 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(string index, object bod
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchAsync(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_msearch".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21357,27 +23457,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index,
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Msearch<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Msearch<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_msearch".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21390,27 +23492,29 @@ public ElasticsearchResponse<T> Msearch<T>(string index, string type, object bod
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MsearchAsync<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_msearch".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21424,26 +23528,30 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, string type,
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Msearch(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Msearch(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_msearch".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21457,26 +23565,30 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(string index, string typ
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchAsync(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_msearch".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MultiSearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MultiSearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21486,25 +23598,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index,
 		///<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-multi-termvectors.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MtermvectorsGet<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MtermvectorsGet<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			var url = "_mtermvectors";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21514,25 +23628,27 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(Func<MtermvectorsRequestParam
 		///<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-multi-termvectors.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MtermvectorsGetAsync<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			var url = "_mtermvectors";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21543,24 +23659,28 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(Func<MtermvectorsR
 		///<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/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MtermvectorsGet(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			var url = "_mtermvectors";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21571,24 +23691,28 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(Func<Mtermvector
 		///<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/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsGetAsync(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			var url = "_mtermvectors";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21599,26 +23723,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MtermvectorsGet<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21629,26 +23755,28 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, Func<Mtermvecto
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MtermvectorsGetAsync<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21660,25 +23788,29 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MtermvectorsGet(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21690,25 +23822,29 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsGetAsync(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21720,27 +23856,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(strin
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> MtermvectorsGet<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mtermvectors".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21752,27 +23890,29 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Fu
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MtermvectorsGetAsync<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mtermvectors".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21785,26 +23925,30 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, stri
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MtermvectorsGet(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mtermvectors".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21817,26 +23961,30 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, st
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsGetAsync(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mtermvectors".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21847,25 +23995,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(strin
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mtermvectors<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mtermvectors<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			var url = "_mtermvectors".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21876,25 +24026,27 @@ public ElasticsearchResponse<T> Mtermvectors<T>(object body, Func<MtermvectorsRe
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MtermvectorsAsync<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			var url = "_mtermvectors".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21906,24 +24058,28 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(object body, Func<Mte
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mtermvectors(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mtermvectors(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			var url = "_mtermvectors".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21935,24 +24091,28 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(object body, Func<M
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 	    ///</summary>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsAsync(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			var url = "_mtermvectors".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -21964,26 +24124,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(object b
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mtermvectors<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mtermvectors<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -21995,26 +24157,28 @@ public ElasticsearchResponse<T> Mtermvectors<T>(string index, object body, Func<
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MtermvectorsAsync<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22027,25 +24191,29 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, object
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mtermvectors(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22058,25 +24226,29 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, objec
 	    ///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsAsync(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_mtermvectors".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22089,27 +24261,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string i
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Mtermvectors<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mtermvectors".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22122,27 +24296,29 @@ public ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, objec
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> MtermvectorsAsync<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mtermvectors".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22156,26 +24332,30 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, string
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mtermvectors(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mtermvectors".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22189,26 +24369,30 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, strin
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsAsync(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_mtermvectors".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new MtermvectorsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new MtermvectorsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22218,25 +24402,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string i
 		///<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/cluster-nodes-hot-threads.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesHotThreadsForAll<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesHotThreadsForAll<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/nodes/hotthreads";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesHotThreadsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesHotThreadsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22246,25 +24432,27 @@ public ElasticsearchResponse<T> NodesHotThreadsForAll<T>(Func<NodesHotThreadsReq
 		///<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/cluster-nodes-hot-threads.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesHotThreadsForAllAsync<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesHotThreadsForAllAsync<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/nodes/hotthreads";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesHotThreadsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesHotThreadsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22275,24 +24463,28 @@ public Task<ElasticsearchResponse<T>> NodesHotThreadsForAllAsync<T>(Func<NodesHo
 		///<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/1.x/cluster-nodes-hot-threads.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesHotThreadsForAll(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesHotThreadsForAll(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/nodes/hotthreads";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesHotThreadsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesHotThreadsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22303,24 +24495,28 @@ public ElasticsearchResponse<DynamicDictionary> NodesHotThreadsForAll(Func<Nodes
 		///<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/1.x/cluster-nodes-hot-threads.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesHotThreadsForAllAsync(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsForAllAsync(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null)
 		{
 			var url = "_cluster/nodes/hotthreads";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesHotThreadsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesHotThreadsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22331,26 +24527,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsForAllAsync
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesHotThreads<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesHotThreads<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/hotthreads".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesHotThreadsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesHotThreadsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22361,26 +24559,28 @@ public ElasticsearchResponse<T> NodesHotThreads<T>(string node_id, Func<NodesHot
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesHotThreadsAsync<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesHotThreadsAsync<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/hotthreads".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesHotThreadsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesHotThreadsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22392,25 +24592,29 @@ public Task<ElasticsearchResponse<T>> NodesHotThreadsAsync<T>(string node_id, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesHotThreads(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesHotThreads(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/hotthreads".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesHotThreadsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesHotThreadsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22422,25 +24626,29 @@ public ElasticsearchResponse<DynamicDictionary> NodesHotThreads(string node_id,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesHotThreadsAsync(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsAsync(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/hotthreads".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesHotThreadsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesHotThreadsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22450,25 +24658,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsAsync(strin
 		///<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/cluster-nodes-info.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesInfoForAll<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesInfoForAll<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			var url = "_nodes";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22478,25 +24688,27 @@ public ElasticsearchResponse<T> NodesInfoForAll<T>(Func<NodesInfoRequestParamete
 		///<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/cluster-nodes-info.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesInfoForAllAsync<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			var url = "_nodes";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22507,24 +24719,28 @@ public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(Func<NodesInfoRequ
 		///<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/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesInfoForAll(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			var url = "_nodes";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22535,24 +24751,28 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(Func<NodesInfoRe
 		///<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/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesInfoForAllAsync(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			var url = "_nodes";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22563,26 +24783,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesInfo<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesInfo<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22593,26 +24815,28 @@ public ElasticsearchResponse<T> NodesInfo<T>(string node_id, Func<NodesInfoReque
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesInfoAsync<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22624,25 +24848,29 @@ public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, Func<Nod
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesInfo(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22654,25 +24882,29 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, Func<N
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesInfoAsync(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22683,26 +24915,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesInfoForAll<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesInfoForAll<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22713,26 +24947,28 @@ public ElasticsearchResponse<T> NodesInfoForAll<T>(string metric, Func<NodesInfo
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesInfoForAllAsync<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22744,25 +24980,29 @@ public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(string metric, Fun
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesInfoForAll(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22774,25 +25014,29 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(string metric, F
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 	    ///</summary>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesInfoForAllAsync(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22804,27 +25048,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(strin
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesInfo<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}/{1}".F(Encoded(node_id), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22836,27 +25082,29 @@ public ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesInfoAsync<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}/{1}".F(Encoded(node_id), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22869,26 +25117,30 @@ public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string m
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesInfo(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}/{1}".F(Encoded(node_id), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22901,26 +25153,30 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, string
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesInfoAsync(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}/{1}".F(Encoded(node_id), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesInfoRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesInfoRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -22930,25 +25186,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node
 		///<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/cluster-nodes-shutdown.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesShutdownForAll<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesShutdownForAll<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null)
 		{
 			var url = "_shutdown";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesShutdownRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesShutdownRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22958,25 +25216,27 @@ public ElasticsearchResponse<T> NodesShutdownForAll<T>(Func<NodesShutdownRequest
 		///<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/cluster-nodes-shutdown.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesShutdownForAllAsync<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesShutdownForAllAsync<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null)
 		{
 			var url = "_shutdown";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesShutdownRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesShutdownRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -22987,24 +25247,28 @@ public Task<ElasticsearchResponse<T>> NodesShutdownForAllAsync<T>(Func<NodesShut
 		///<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/1.x/cluster-nodes-shutdown.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesShutdownForAll(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesShutdownForAll(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null)
 		{
 			var url = "_shutdown";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesShutdownRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesShutdownRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23015,24 +25279,28 @@ public ElasticsearchResponse<DynamicDictionary> NodesShutdownForAll(Func<NodesSh
 		///<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/1.x/cluster-nodes-shutdown.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesShutdownForAllAsync(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownForAllAsync(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null)
 		{
 			var url = "_shutdown";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesShutdownRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesShutdownRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23043,26 +25311,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownForAllAsync(F
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you&#39;re connected to, leave empty to perform the operation on all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesShutdown<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesShutdown<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/_shutdown".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesShutdownRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesShutdownRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23073,26 +25343,28 @@ public ElasticsearchResponse<T> NodesShutdown<T>(string node_id, Func<NodesShutd
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you&#39;re connected to, leave empty to perform the operation on all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesShutdownAsync<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesShutdownAsync<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/_shutdown".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesShutdownRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesShutdownRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23104,25 +25376,29 @@ public Task<ElasticsearchResponse<T>> NodesShutdownAsync<T>(string node_id, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you&#39;re connected to, leave empty to perform the operation on all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesShutdown(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesShutdown(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/_shutdown".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesShutdownRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesShutdownRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23134,25 +25410,29 @@ public ElasticsearchResponse<DynamicDictionary> NodesShutdown(string node_id, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you&#39;re connected to, leave empty to perform the operation on all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesShutdownAsync(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownAsync(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cluster/nodes/{0}/_shutdown".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesShutdownRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesShutdownRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23162,25 +25442,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownAsync(string
 		///<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/cluster-nodes-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesStatsForAll<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStatsForAll<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_nodes/stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23190,25 +25472,27 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(Func<NodesStatsRequestParame
 		///<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/cluster-nodes-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesStatsForAllAsync<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_nodes/stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23219,24 +25503,28 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(Func<NodesStatsRe
 		///<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/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStatsForAll(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_nodes/stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23247,24 +25535,28 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(Func<NodesStats
 		///<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/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsForAllAsync(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			var url = "_nodes/stats";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23275,26 +25567,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesStats<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStats<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}/stats".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23305,26 +25599,28 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, Func<NodesStatsReq
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesStatsAsync<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}/stats".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23336,25 +25632,29 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, Func<No
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStats(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}/stats".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23366,25 +25666,29 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, Func<
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsAsync(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_nodes/{0}/stats".F(Encoded(node_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23395,26 +25699,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesStatsForAll<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/stats/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23425,26 +25731,28 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, Func<NodesSta
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesStatsForAllAsync<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/stats/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23456,25 +25764,29 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, Fu
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStatsForAll(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/stats/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23486,25 +25798,29 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric,
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsForAllAsync(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/stats/{0}".F(Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23516,27 +25832,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(stri
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesStats<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}/stats/{1}".F(Encoded(node_id), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23548,27 +25866,29 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, Fun
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesStatsAsync<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}/stats/{1}".F(Encoded(node_id), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23581,26 +25901,30 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStats(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}/stats/{1}".F(Encoded(node_id), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23613,26 +25937,30 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, strin
 	    ///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsAsync(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			var url = "_nodes/{0}/stats/{1}".F(Encoded(node_id), Encoded(metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23644,27 +25972,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesStatsForAll<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
 			var url = "_nodes/stats/{0}/{1}".F(Encoded(metric), Encoded(index_metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23676,27 +26006,29 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, string index_
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesStatsForAllAsync<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
 			var url = "_nodes/stats/{0}/{1}".F(Encoded(metric), Encoded(index_metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23709,26 +26041,30 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, st
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStatsForAll(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
 			var url = "_nodes/stats/{0}/{1}".F(Encoded(metric), Encoded(index_metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23741,26 +26077,30 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric,
 	    ///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsForAllAsync(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
 			var url = "_nodes/stats/{0}/{1}".F(Encoded(metric), Encoded(index_metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23773,28 +26113,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(stri
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> NodesStats<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
 			var url = "_nodes/{0}/stats/{1}/{2}".F(Encoded(node_id), Encoded(metric), Encoded(index_metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23807,28 +26149,30 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, str
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> NodesStatsAsync<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
 			var url = "_nodes/{0}/stats/{1}/{2}".F(Encoded(node_id), Encoded(metric), Encoded(index_metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23842,27 +26186,31 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStats(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
 			var url = "_nodes/{0}/stats/{1}/{2}".F(Encoded(node_id), Encoded(metric), Encoded(index_metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23876,27 +26224,31 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, strin
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsAsync(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			metric.ThrowIfNullOrEmpty("metric");
 			index_metric.ThrowIfNullOrEmpty("index_metric");
 			var url = "_nodes/{0}/stats/{1}/{2}".F(Encoded(node_id), Encoded(metric), Encoded(index_metric));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new NodesStatsRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new NodesStatsRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -23908,27 +26260,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 	    ///</summary>
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> PercolateGet<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23940,27 +26294,29 @@ public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, Func<
 	    ///</summary>
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> PercolateGetAsync<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -23973,26 +26329,30 @@ public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string
 	    ///</summary>
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> PercolateGet(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24005,26 +26365,30 @@ public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, strin
 	    ///</summary>
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PercolateGetAsync(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24037,28 +26401,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string i
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> PercolateGet<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24071,28 +26437,30 @@ public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, strin
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> PercolateGetAsync<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24106,27 +26474,31 @@ public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> PercolateGet(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24140,27 +26512,31 @@ public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, strin
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PercolateGetAsync(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24173,27 +26549,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string i
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Percolate<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Percolate<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24206,27 +26584,29 @@ public ElasticsearchResponse<T> Percolate<T>(string index, string type, object b
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> PercolateAsync<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24240,26 +26620,30 @@ public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string typ
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Percolate(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24273,26 +26657,30 @@ public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string t
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PercolateAsync(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_percolate".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24306,28 +26694,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string inde
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Percolate<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Percolate<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24341,28 +26731,30 @@ public ElasticsearchResponse<T> Percolate<T>(string index, string type, string i
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> PercolateAsync<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24377,27 +26769,31 @@ public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string typ
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Percolate(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24412,27 +26808,31 @@ public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string t
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PercolateAsync(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_percolate".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PercolateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PercolateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24442,25 +26842,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string inde
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 	    ///<para>See also: http://www.elasticsearch.org/guide/</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Ping<T>(Func<PingRequestParameters, PingRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Ping<T>(Func<PingRequestParameters, PingRequestParameters> requestParameters = null)
 		{
 			var url = "";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24470,25 +26872,27 @@ public ElasticsearchResponse<T> Ping<T>(Func<PingRequestParameters, PingRequestP
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 	    ///<para>See also: http://www.elasticsearch.org/guide/</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> PingAsync<T>(Func<PingRequestParameters, PingRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> PingAsync<T>(Func<PingRequestParameters, PingRequestParameters> requestParameters = null)
 		{
 			var url = "";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("HEAD", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24499,24 +26903,28 @@ public Task<ElasticsearchResponse<T>> PingAsync<T>(Func<PingRequestParameters, P
 		///<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/</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Ping(Func<PingRequestParameters, PingRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Ping(Func<PingRequestParameters, PingRequestParameters> requestParameters = null)
 		{
 			var url = "";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24527,24 +26935,28 @@ public ElasticsearchResponse<DynamicDictionary> Ping(Func<PingRequestParameters,
 		///<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/</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PingAsync(Func<PingRequestParameters, PingRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingRequestParameters, PingRequestParameters> requestParameters = null)
 		{
 			var url = "";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new PingRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new PingRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("HEAD", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"HEAD", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24554,25 +26966,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingRequest
 		///<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/search-request-scroll.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ScrollGet<T>(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ScrollGet<T>(Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			var url = "_search/scroll";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24582,25 +26996,27 @@ public ElasticsearchResponse<T> ScrollGet<T>(Func<ScrollRequestParameters, Scrol
 		///<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/search-request-scroll.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ScrollGetAsync<T>(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			var url = "_search/scroll";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24611,24 +27027,28 @@ public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(Func<ScrollRequestParame
 		///<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/1.x/search-request-scroll.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ScrollGet(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ScrollGet(Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			var url = "_search/scroll";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24639,24 +27059,28 @@ public ElasticsearchResponse<DynamicDictionary> ScrollGet(Func<ScrollRequestPara
 		///<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/1.x/search-request-scroll.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ScrollGetAsync(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			var url = "_search/scroll";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24667,26 +27091,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(Func<Scroll
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="scroll_id">The scroll ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> ScrollGet<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> ScrollGet<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24697,26 +27123,28 @@ public ElasticsearchResponse<T> ScrollGet<T>(string scroll_id, Func<ScrollReques
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="scroll_id">The scroll ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ScrollGetAsync<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24728,25 +27156,29 @@ public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(string scroll_id, Func<S
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="scroll_id">The scroll ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ScrollGet(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> ScrollGet(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24758,25 +27190,29 @@ public ElasticsearchResponse<DynamicDictionary> ScrollGet(string scroll_id, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="scroll_id">The scroll ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ScrollGetAsync(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24787,25 +27223,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(string scro
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Scroll<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Scroll<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			var url = "_search/scroll".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24816,25 +27254,27 @@ public ElasticsearchResponse<T> Scroll<T>(object body, Func<ScrollRequestParamet
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ScrollAsync<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ScrollAsync<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			var url = "_search/scroll".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24846,24 +27286,28 @@ public Task<ElasticsearchResponse<T>> ScrollAsync<T>(object body, Func<ScrollReq
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Scroll(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Scroll(object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			var url = "_search/scroll".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24875,24 +27319,28 @@ public ElasticsearchResponse<DynamicDictionary> Scroll(object body, Func<ScrollR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 	    ///</summary>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ScrollAsync(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			var url = "_search/scroll".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24904,26 +27352,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(object body, F
 	    ///</summary>
 		///<param name="scroll_id">The scroll ID</param>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Scroll<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Scroll<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24935,26 +27385,28 @@ public ElasticsearchResponse<T> Scroll<T>(string scroll_id, object body, Func<Sc
 	    ///</summary>
 		///<param name="scroll_id">The scroll ID</param>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> ScrollAsync<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> ScrollAsync<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -24967,25 +27419,29 @@ public Task<ElasticsearchResponse<T>> ScrollAsync<T>(string scroll_id, object bo
 	    ///</summary>
 		///<param name="scroll_id">The scroll ID</param>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Scroll(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Scroll(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -24998,25 +27454,29 @@ public ElasticsearchResponse<DynamicDictionary> Scroll(string scroll_id, object
 	    ///</summary>
 		///<param name="scroll_id">The scroll ID</param>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ScrollAsync(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null)
 		{
 			scroll_id.ThrowIfNullOrEmpty("scroll_id");
 			var url = "_search/scroll/{0}".F(Encoded(scroll_id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new ScrollRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new ScrollRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25026,25 +27486,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(string scroll_
 		///<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/search-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SearchGet<T>(Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SearchGet<T>(Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			var url = "_search";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25054,25 +27516,27 @@ public ElasticsearchResponse<T> SearchGet<T>(Func<SearchRequestParameters, Searc
 		///<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/search-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SearchGetAsync<T>(Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			var url = "_search";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25083,24 +27547,28 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(Func<SearchRequestParame
 		///<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/1.x/search-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SearchGet(Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SearchGet(Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			var url = "_search";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25111,24 +27579,28 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(Func<SearchRequestPara
 		///<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/1.x/search-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchGetAsync(Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			var url = "_search";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25139,26 +27611,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(Func<Search
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SearchGet<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SearchGet<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25169,26 +27643,28 @@ public ElasticsearchResponse<T> SearchGet<T>(string index, Func<SearchRequestPar
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SearchGetAsync<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25200,25 +27676,29 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, Func<Searc
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SearchGet(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25230,25 +27710,29 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, Func<Sea
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchGetAsync(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25260,27 +27744,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string inde
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SearchGet<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SearchGet<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_search".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25292,27 +27778,29 @@ public ElasticsearchResponse<T> SearchGet<T>(string index, string type, Func<Sea
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SearchGetAsync<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_search".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25325,26 +27813,30 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, string typ
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SearchGet(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_search".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25357,26 +27849,30 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, string t
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchGetAsync(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_search".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25387,25 +27883,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string inde
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Search<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Search<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			var url = "_search".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25416,25 +27914,27 @@ public ElasticsearchResponse<T> Search<T>(object body, Func<SearchRequestParamet
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SearchAsync<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchAsync<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			var url = "_search".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25446,24 +27946,28 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(object body, Func<SearchReq
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Search(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Search(object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			var url = "_search".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25475,24 +27979,28 @@ public ElasticsearchResponse<DynamicDictionary> Search(object body, Func<SearchR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchAsync(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			var url = "_search".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25504,26 +28012,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(object body, F
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Search<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Search<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25535,26 +28045,28 @@ public ElasticsearchResponse<T> Search<T>(string index, object body, Func<Search
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SearchAsync<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25567,25 +28079,29 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, object body,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Search(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Search(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25598,25 +28114,29 @@ public ElasticsearchResponse<DynamicDictionary> Search(string index, object body
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchAsync(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_search".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25629,27 +28149,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index,
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Search<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Search<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_search".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25662,27 +28184,29 @@ public ElasticsearchResponse<T> Search<T>(string index, string type, object body
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SearchAsync<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_search".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25696,26 +28220,30 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, string type,
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Search(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Search(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_search".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25729,26 +28257,30 @@ public ElasticsearchResponse<DynamicDictionary> Search(string index, string type
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchAsync(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			var url = "{0}/{1}/_search".F(Encoded(index), Encoded(type));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SearchRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SearchRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25761,27 +28293,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index,
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotCreate<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotCreate<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25794,27 +28328,29 @@ public ElasticsearchResponse<T> SnapshotCreate<T>(string repository, string snap
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotCreateAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotCreateAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25828,26 +28364,30 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateAsync<T>(string repository,
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotCreate(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotCreate(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25861,26 +28401,30 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreate(string repository
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotCreateAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25893,27 +28437,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateAsync(string
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotCreatePost<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotCreatePost<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25926,27 +28472,29 @@ public ElasticsearchResponse<T> SnapshotCreatePost<T>(string repository, string
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotCreatePostAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotCreatePostAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -25960,26 +28508,30 @@ public Task<ElasticsearchResponse<T>> SnapshotCreatePostAsync<T>(string reposito
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotCreatePost(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotCreatePost(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -25993,26 +28545,30 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreatePost(string reposi
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotCreatePostAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreatePostAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26024,26 +28580,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreatePostAsync(st
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotCreateRepository<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotCreateRepository<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26055,26 +28613,28 @@ public ElasticsearchResponse<T> SnapshotCreateRepository<T>(string repository, o
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotCreateRepositoryAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("PUT", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26087,25 +28647,29 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryAsync<T>(string re
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotCreateRepository(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepository(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26118,25 +28682,29 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepository(string
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotCreateRepositoryAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("PUT", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"PUT", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26148,26 +28716,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryAs
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotCreateRepositoryPost<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotCreateRepositoryPost<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26179,26 +28749,28 @@ public ElasticsearchResponse<T> SnapshotCreateRepositoryPost<T>(string repositor
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotCreateRepositoryPostAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryPostAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26211,25 +28783,29 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryPostAsync<T>(strin
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotCreateRepositoryPost(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepositoryPost(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26242,25 +28818,29 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepositoryPost(str
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotCreateRepositoryPostAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryPostAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotCreateRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotCreateRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26272,27 +28852,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryPo
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotDelete<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotDelete<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotDeleteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotDeleteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26304,27 +28886,29 @@ public ElasticsearchResponse<T> SnapshotDelete<T>(string repository, string snap
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotDeleteAsync<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotDeleteAsync<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotDeleteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotDeleteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26337,26 +28921,30 @@ public Task<ElasticsearchResponse<T>> SnapshotDeleteAsync<T>(string repository,
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotDelete(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotDelete(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotDeleteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotDeleteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26369,26 +28957,30 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotDelete(string repository
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotDeleteAsync(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteAsync(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotDeleteRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotDeleteRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26399,26 +28991,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteAsync(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 	    ///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotDeleteRepository<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotDeleteRepository<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotDeleteRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotDeleteRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26429,26 +29023,28 @@ public ElasticsearchResponse<T> SnapshotDeleteRepository<T>(string repository, F
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 	    ///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotDeleteRepositoryAsync<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryAsync<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotDeleteRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotDeleteRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("DELETE", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26460,25 +29056,29 @@ public Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryAsync<T>(string re
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 	    ///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotDeleteRepository(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotDeleteRepository(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotDeleteRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotDeleteRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26490,25 +29090,29 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotDeleteRepository(string
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 	    ///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotDeleteRepositoryAsync(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteRepositoryAsync(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotDeleteRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotDeleteRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("DELETE", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"DELETE", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26520,27 +29124,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteRepositoryAs
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A comma-separated list of snapshot names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotGet<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotGet<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26552,27 +29158,29 @@ public ElasticsearchResponse<T> SnapshotGet<T>(string repository, string snapsho
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A comma-separated list of snapshot names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotGetAsync<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotGetAsync<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26585,26 +29193,30 @@ public Task<ElasticsearchResponse<T>> SnapshotGetAsync<T>(string repository, str
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A comma-separated list of snapshot names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotGet(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotGet(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26617,26 +29229,30 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGet(string repository, s
 	    ///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A comma-separated list of snapshot names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotGetAsync(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetAsync(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26646,25 +29262,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetAsync(string re
 		///<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/modules-snapshots.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotGetRepository<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotGetRepository<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null)
 		{
 			var url = "_snapshot";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26674,25 +29292,27 @@ public ElasticsearchResponse<T> SnapshotGetRepository<T>(Func<SnapshotGetReposit
 		///<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/modules-snapshots.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotGetRepositoryAsync<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null)
 		{
 			var url = "_snapshot";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26703,24 +29323,28 @@ public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(Func<Snapsho
 		///<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/1.x/modules-snapshots.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotGetRepository(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null)
 		{
 			var url = "_snapshot";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26731,24 +29355,28 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(Func<Snaps
 		///<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/1.x/modules-snapshots.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotGetRepositoryAsync(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null)
 		{
 			var url = "_snapshot";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26759,26 +29387,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 	    ///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotGetRepository<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotGetRepository<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26789,26 +29419,28 @@ public ElasticsearchResponse<T> SnapshotGetRepository<T>(string repository, Func
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 	    ///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotGetRepositoryAsync<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26820,25 +29452,29 @@ public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(string repos
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 	    ///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotGetRepository(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26850,25 +29486,29 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(string rep
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 	    ///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotGetRepositoryAsync(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			var url = "_snapshot/{0}".F(Encoded(repository));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotGetRepositoryRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotGetRepositoryRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26881,27 +29521,29 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">Details of what to restore</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SnapshotRestore<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SnapshotRestore<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}/_restore".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRestoreRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRestoreRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26914,27 +29556,29 @@ public ElasticsearchResponse<T> SnapshotRestore<T>(string repository, string sna
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">Details of what to restore</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SnapshotRestoreAsync<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SnapshotRestoreAsync<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}/_restore".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRestoreRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRestoreRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -26948,26 +29592,30 @@ public Task<ElasticsearchResponse<T>> SnapshotRestoreAsync<T>(string repository,
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">Details of what to restore</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotRestore(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SnapshotRestore(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}/_restore".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRestoreRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRestoreRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -26981,26 +29629,30 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotRestore(string repositor
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">Details of what to restore</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotRestoreAsync(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotRestoreAsync(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> requestParameters = null)
 		{
 			repository.ThrowIfNullOrEmpty("repository");
 			snapshot.ThrowIfNullOrEmpty("snapshot");
 			var url = "_snapshot/{0}/{1}/_restore".F(Encoded(repository), Encoded(snapshot));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SnapshotRestoreRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SnapshotRestoreRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27011,25 +29663,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotRestoreAsync(strin
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Suggest<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Suggest<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			var url = "_suggest".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27040,25 +29694,27 @@ public ElasticsearchResponse<T> Suggest<T>(object body, Func<SuggestRequestParam
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SuggestAsync<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SuggestAsync<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			var url = "_suggest".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27070,24 +29726,28 @@ public Task<ElasticsearchResponse<T>> SuggestAsync<T>(object body, Func<SuggestR
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Suggest(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Suggest(object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			var url = "_suggest".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27099,24 +29759,28 @@ public ElasticsearchResponse<DynamicDictionary> Suggest(object body, Func<Sugges
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SuggestAsync(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			var url = "_suggest".F();
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27128,26 +29792,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(object body,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Suggest<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Suggest<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27159,26 +29825,28 @@ public ElasticsearchResponse<T> Suggest<T>(string index, object body, Func<Sugge
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SuggestAsync<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SuggestAsync<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27191,25 +29859,29 @@ public Task<ElasticsearchResponse<T>> SuggestAsync<T>(string index, object body,
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Suggest(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Suggest(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27222,25 +29894,29 @@ public ElasticsearchResponse<DynamicDictionary> Suggest(string index, object bod
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SuggestAsync(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27250,25 +29926,27 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(string index,
 		///<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/search-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SuggestGet<T>(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SuggestGet<T>(Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			var url = "_suggest";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27278,25 +29956,27 @@ public ElasticsearchResponse<T> SuggestGet<T>(Func<SuggestRequestParameters, Sug
 		///<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/search-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SuggestGetAsync<T>(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			var url = "_suggest";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27307,24 +29987,28 @@ public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(Func<SuggestRequestPara
 		///<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/1.x/search-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SuggestGet(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SuggestGet(Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			var url = "_suggest";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27335,24 +30019,28 @@ public ElasticsearchResponse<DynamicDictionary> SuggestGet(Func<SuggestRequestPa
 		///<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/1.x/search-search.html</para>	
 	    ///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SuggestGetAsync(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			var url = "_suggest";
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27363,26 +30051,28 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(Func<Sugge
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> SuggestGet<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> SuggestGet<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27393,26 +30083,28 @@ public ElasticsearchResponse<T> SuggestGet<T>(string index, Func<SuggestRequestP
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> SuggestGetAsync<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27424,25 +30116,29 @@ public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(string index, Func<Sugg
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SuggestGet(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> SuggestGet(string index, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27454,25 +30150,29 @@ public ElasticsearchResponse<DynamicDictionary> SuggestGet(string index, Func<Su
 	    ///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 	    ///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SuggestGetAsync(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(string index, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "{0}/_suggest".F(Encoded(index));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new SuggestRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new SuggestRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27485,28 +30185,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(string ind
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> TermvectorGet<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_termvector".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new TermvectorRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new TermvectorRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27519,28 +30221,30 @@ public ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, stri
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> TermvectorGetAsync<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> TermvectorGetAsync<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_termvector".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new TermvectorRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new TermvectorRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("GET", url, data: null, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27554,27 +30258,31 @@ public Task<ElasticsearchResponse<T>> TermvectorGetAsync<T>(string index, string
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> TermvectorGet(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_termvector".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new TermvectorRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new TermvectorRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27588,27 +30296,31 @@ public ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, stri
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> TermvectorGetAsync(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorGetAsync(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_termvector".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new TermvectorRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new TermvectorRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("GET", url, data: null, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"GET", url, data: null, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27622,28 +30334,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorGetAsync(string
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
 		///<param name="body">Define parameters. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Termvector<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Termvector<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_termvector".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new TermvectorRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new TermvectorRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27657,28 +30371,30 @@ public ElasticsearchResponse<T> Termvector<T>(string index, string type, string
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
 		///<param name="body">Define parameters. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> TermvectorAsync<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> TermvectorAsync<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_termvector".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new TermvectorRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new TermvectorRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27693,27 +30409,31 @@ public Task<ElasticsearchResponse<T>> TermvectorAsync<T>(string index, string ty
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
 		///<param name="body">Define parameters. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Termvector(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Termvector(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_termvector".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new TermvectorRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new TermvectorRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27728,27 +30448,31 @@ public ElasticsearchResponse<DynamicDictionary> Termvector(string index, string
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
 		///<param name="body">Define parameters. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> TermvectorAsync(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_termvector".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new TermvectorRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new TermvectorRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27762,28 +30486,30 @@ public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string ind
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The request definition using either `script` or partial `doc`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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> Update<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null, object deserializationState = null)
+		public ElasticsearchResponse<T> Update<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_update".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequest<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequest<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27797,28 +30523,30 @@ public ElasticsearchResponse<T> Update<T>(string index, string type, string id,
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The request definition using either `script` or partial `doc`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-		///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</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>> UpdateAsync<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null, object deserializationState = null)
+		public Task<ElasticsearchResponse<T>> UpdateAsync<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_update".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return this.DoRequestAsync<T>("POST", url, body, 
-				queryString: nv
-				, deserializationState: deserializationState
+			return this.DoRequestAsync<T>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			);
 		}
 		
@@ -27833,27 +30561,31 @@ public Task<ElasticsearchResponse<T>> UpdateAsync<T>(string index, string type,
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The request definition using either `script` or partial `doc`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Update(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null)
+		public ElasticsearchResponse<DynamicDictionary> Update(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_update".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 		
@@ -27868,27 +30600,31 @@ public ElasticsearchResponse<DynamicDictionary> Update(string index, string type
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The request definition using either `script` or partial `doc`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> UpdateAsync(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null)
+		public Task<ElasticsearchResponse<DynamicDictionary>> UpdateAsync(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			type.ThrowIfNullOrEmpty("type");
 			id.ThrowIfNullOrEmpty("id");
 			var url = "{0}/{1}/{2}/_update".F(Encoded(index), Encoded(type), Encoded(id));
-			NameValueCollection nv = null;
-			if (queryString != null)
+			BaseRequestParameters requestParams = null;
+			if (requestParameters != null)
 			{
-				var qs = queryString(new UpdateRequestParameters());
-				if (qs != null) nv = this.ToNameValueCollection(qs);
+				requestParams = requestParameters(new UpdateRequestParameters());
+				ToNameValueCollection(requestParams);
 			}
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>("POST", url, body, 
-				queryString: nv
+			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+				"POST", url, body, 
+				requestParameters: requestParams
 			));
 		}
 	
diff --git a/src/Elasticsearch.Net/ElasticsearchClient.cs b/src/Elasticsearch.Net/ElasticsearchClient.cs
index 18fdf20274a..87a763d909e 100644
--- a/src/Elasticsearch.Net/ElasticsearchClient.cs
+++ b/src/Elasticsearch.Net/ElasticsearchClient.cs
@@ -49,21 +49,20 @@ public ElasticsearchClient(
 				this.Transport.Sniff(fromStartup: true);
 		}
 
-		protected NameValueCollection ToNameValueCollection<TQueryString>(FluentRequestParameters<TQueryString> qs)
-			where TQueryString : FluentRequestParameters<TQueryString>
+		protected void ToNameValueCollection(BaseRequestParameters requestParameters)
 		{
-			if (qs == null)
-				return null;
-			var dict = qs._QueryStringDictionary;
+			if (requestParameters == null)
+				return;
+			var dict = requestParameters._QueryStringDictionary;
 			if (dict == null || dict.Count < 0)
-				return null;
-
+				return;
+			
 			var nv = new NameValueCollection();
 			foreach (var kv in dict.Where(kv => !kv.Key.IsNullOrEmpty()))
 			{
 				nv.Add(kv.Key, this.Stringifier.Stringify(kv.Value));
 			}
-			return nv;
+			requestParameters._queryString = nv;
 		}
 
 		public string Encoded(object o)
@@ -72,15 +71,15 @@ public string Encoded(object o)
 		}
 
 
-		protected ElasticsearchResponse<T> DoRequest<T>(string method, string path, object data = null, NameValueCollection queryString = null, object deserializationState = null)
+		protected ElasticsearchResponse<T> DoRequest<T>(string method, string path, object data = null, BaseRequestParameters requestParameters = null)
 		{
-			return this.Transport.DoRequest<T>(method, path, data, queryString, deserializationState);
+			return this.Transport.DoRequest<T>(method, path, data, requestParameters);
 		}
 
 
-		protected Task<ElasticsearchResponse<T>> DoRequestAsync<T>(string method, string path, object data = null, NameValueCollection queryString = null, object deserializationState = null)
+		protected Task<ElasticsearchResponse<T>> DoRequestAsync<T>(string method, string path, object data = null, BaseRequestParameters requestParameters = null)
 		{
-			return this.Transport.DoRequestAsync<T>(method, path, data, queryString, deserializationState);
+			return this.Transport.DoRequestAsync<T>(method, path, data, requestParameters);
 		}
 	}
 }
diff --git a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
index 6b135a03a9d..0558f583e90 100644
--- a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
@@ -31,13 +31,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 		///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Bulk<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Bulk<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -46,13 +49,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 		///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> BulkAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -62,14 +68,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 		///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Bulk(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Bulk(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -79,14 +88,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 		///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -96,13 +108,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Bulk<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Bulk<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -112,13 +127,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> BulkAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -129,14 +147,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Bulk(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Bulk(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -147,14 +168,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -165,13 +189,16 @@ public interface IElasticsearchClient
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Bulk<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Bulk<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -182,13 +209,16 @@ public interface IElasticsearchClient
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> BulkAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -200,14 +230,17 @@ public interface IElasticsearchClient
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Bulk(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Bulk(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -219,14 +252,17 @@ public interface IElasticsearchClient
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -235,13 +271,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 		///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> BulkPut<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> BulkPut<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -250,13 +289,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 		///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> BulkPutAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkPutAsync<T>(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -266,14 +308,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 		///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> BulkPut(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> BulkPut(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -283,14 +328,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-bulk.html</para>	
 		///</summary>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkPutAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -300,13 +348,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> BulkPut<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> BulkPut<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -316,13 +367,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> BulkPutAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -333,14 +387,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> BulkPut(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> BulkPut(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -351,14 +408,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkPutAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -369,13 +429,16 @@ public interface IElasticsearchClient
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> BulkPut<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> BulkPut<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_bulk
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -386,13 +449,16 @@ public interface IElasticsearchClient
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> BulkPutAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_bulk
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -404,14 +470,17 @@ public interface IElasticsearchClient
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> BulkPut(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> BulkPut(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_bulk
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -423,14 +492,17 @@ public interface IElasticsearchClient
 		///<param name="index">Default index for items which don&#39;t provide one</param>
 		///<param name="type">Default document type for items which don&#39;t provide one</param>
 		///<param name="body">The operation definition and data (action-data pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> BulkPutAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index, string type, object body, Func<BulkRequestParameters, BulkRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -438,13 +510,16 @@ public interface IElasticsearchClient
 		///<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/cat-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatAliases<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatAliases<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -452,13 +527,16 @@ public interface IElasticsearchClient
 		///<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/cat-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatAliasesAsync<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -467,14 +545,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -483,14 +564,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -499,13 +583,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatAliases<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatAliases<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -514,13 +601,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatAliasesAsync<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -530,14 +620,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -547,14 +640,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -562,13 +658,16 @@ public interface IElasticsearchClient
 		///<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/cat-allocation.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatAllocation<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatAllocation<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -576,13 +675,16 @@ public interface IElasticsearchClient
 		///<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/cat-allocation.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatAllocationAsync<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -591,14 +693,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-allocation.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -607,14 +712,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-allocation.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -623,13 +731,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatAllocation<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatAllocation<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -638,13 +749,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatAllocationAsync<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -654,14 +768,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -671,14 +788,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-allocation.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -686,13 +806,16 @@ public interface IElasticsearchClient
 		///<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/cat-count.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatCount<T>(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatCount<T>(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -700,13 +823,16 @@ public interface IElasticsearchClient
 		///<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/cat-count.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatCountAsync<T>(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatCountAsync<T>(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -715,14 +841,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-count.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -731,14 +860,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-count.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -747,13 +879,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatCount<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatCount<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -762,13 +897,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatCountAsync<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatCountAsync<T>(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -778,14 +916,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -795,14 +936,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-count.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -810,13 +954,16 @@ public interface IElasticsearchClient
 		///<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/cat-health.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatHealth<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatHealth<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -824,13 +971,16 @@ public interface IElasticsearchClient
 		///<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/cat-health.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatHealthAsync<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatHealthAsync<T>(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -839,14 +989,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-health.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -855,14 +1008,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-health.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -870,13 +1026,16 @@ public interface IElasticsearchClient
 		///<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/cat.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatHelp<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatHelp<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -884,13 +1043,16 @@ public interface IElasticsearchClient
 		///<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/cat.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatHelpAsync<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatHelpAsync<T>(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -899,14 +1061,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -915,14 +1080,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -930,13 +1098,16 @@ public interface IElasticsearchClient
 		///<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/cat-indices.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatIndices<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatIndices<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -944,13 +1115,16 @@ public interface IElasticsearchClient
 		///<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/cat-indices.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatIndicesAsync<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -959,14 +1133,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-indices.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -975,14 +1152,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-indices.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -991,13 +1171,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatIndices<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatIndices<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1006,13 +1189,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatIndicesAsync<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1022,14 +1208,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1039,14 +1228,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-indices.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1054,13 +1246,16 @@ public interface IElasticsearchClient
 		///<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/cat-master.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatMaster<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatMaster<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1068,13 +1263,16 @@ public interface IElasticsearchClient
 		///<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/cat-master.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatMasterAsync<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatMasterAsync<T>(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1083,14 +1281,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-master.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1099,14 +1300,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-master.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1114,13 +1318,16 @@ public interface IElasticsearchClient
 		///<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/cat-nodes.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatNodes<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatNodes<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1128,13 +1335,16 @@ public interface IElasticsearchClient
 		///<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/cat-nodes.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatNodesAsync<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatNodesAsync<T>(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1143,14 +1353,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-nodes.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1159,14 +1372,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-nodes.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1174,13 +1390,16 @@ public interface IElasticsearchClient
 		///<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/cat-pending-tasks.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatPendingTasks<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatPendingTasks<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1188,13 +1407,16 @@ public interface IElasticsearchClient
 		///<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/cat-pending-tasks.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatPendingTasksAsync<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatPendingTasksAsync<T>(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1203,14 +1425,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-pending-tasks.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1219,14 +1444,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-pending-tasks.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1234,13 +1462,16 @@ public interface IElasticsearchClient
 		///<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/cat-recovery.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatRecovery<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatRecovery<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1248,13 +1479,16 @@ public interface IElasticsearchClient
 		///<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/cat-recovery.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatRecoveryAsync<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1263,14 +1497,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-recovery.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1279,14 +1516,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-recovery.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1295,13 +1535,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatRecovery<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatRecovery<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1310,13 +1553,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatRecoveryAsync<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1326,14 +1572,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1343,14 +1592,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-recovery.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1358,13 +1610,16 @@ public interface IElasticsearchClient
 		///<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/cat-shards.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatShards<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatShards<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1372,13 +1627,16 @@ public interface IElasticsearchClient
 		///<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/cat-shards.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatShardsAsync<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatShardsAsync<T>(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1387,14 +1645,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-shards.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1403,14 +1664,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cat-shards.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1419,13 +1683,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatShards<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatShards<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1434,13 +1701,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatShardsAsync<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatShardsAsync<T>(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1450,14 +1720,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1467,14 +1740,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cat-shards.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to limit the returned information</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1482,13 +1758,16 @@ public interface IElasticsearchClient
 		///<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/cat-thread-pool.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CatThreadPool<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CatThreadPool<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1496,13 +1775,16 @@ public interface IElasticsearchClient
 		///<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/cat-thread-pool.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CatThreadPoolAsync<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CatThreadPoolAsync<T>(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1511,14 +1793,17 @@ public interface IElasticsearchClient
 		///<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/cat-thread-pool.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1527,14 +1812,17 @@ public interface IElasticsearchClient
 		///<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/cat-thread-pool.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1543,13 +1831,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="scroll_id">A comma-separated list of scroll IDs to clear</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClearScroll<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClearScroll<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1558,13 +1849,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="scroll_id">A comma-separated list of scroll IDs to clear</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClearScrollAsync<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClearScrollAsync<T>(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1574,14 +1868,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="scroll_id">A comma-separated list of scroll IDs to clear</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClearScroll(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClearScroll(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1591,14 +1888,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="scroll_id">A comma-separated list of scroll IDs to clear</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClearScrollAsync(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClearScrollAsync(string scroll_id, Func<ClearScrollRequestParameters, ClearScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1606,13 +1906,16 @@ public interface IElasticsearchClient
 		///<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/cluster-update-settings.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterGetSettings<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterGetSettings<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1620,13 +1923,16 @@ public interface IElasticsearchClient
 		///<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/cluster-update-settings.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterGetSettingsAsync<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterGetSettingsAsync<T>(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1635,14 +1941,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-update-settings.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterGetSettings(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterGetSettings(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1651,14 +1960,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-update-settings.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterGetSettingsAsync(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterGetSettingsAsync(Func<ClusterGetSettingsRequestParameters, ClusterGetSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/health
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1666,13 +1978,16 @@ public interface IElasticsearchClient
 		///<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/cluster-health.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterHealth<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterHealth<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/health
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1680,13 +1995,16 @@ public interface IElasticsearchClient
 		///<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/cluster-health.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterHealthAsync<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/health
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1695,14 +2013,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-health.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterHealth(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterHealth(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/health
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1711,14 +2032,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-health.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterHealthAsync(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/health/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1727,13 +2051,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html</para>	
 		///</summary>
 		///<param name="index">Limit the information returned to a specific index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterHealth<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterHealth<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/health/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1742,13 +2069,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html</para>	
 		///</summary>
 		///<param name="index">Limit the information returned to a specific index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterHealthAsync<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/health/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1758,14 +2088,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html</para>	
 		///</summary>
 		///<param name="index">Limit the information returned to a specific index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterHealth(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterHealth(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/health/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1775,14 +2108,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-health.html</para>	
 		///</summary>
 		///<param name="index">Limit the information returned to a specific index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterHealthAsync(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(string index, Func<ClusterHealthRequestParameters, ClusterHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/pending_tasks
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1790,13 +2126,16 @@ public interface IElasticsearchClient
 		///<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/cluster-pending.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterPendingTasks<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterPendingTasks<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/pending_tasks
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1804,13 +2143,16 @@ public interface IElasticsearchClient
 		///<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/cluster-pending.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterPendingTasksAsync<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterPendingTasksAsync<T>(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/pending_tasks
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1819,14 +2161,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-pending.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterPendingTasks(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterPendingTasks(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/pending_tasks
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1835,14 +2180,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-pending.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterPendingTasksAsync(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterPendingTasksAsync(Func<ClusterPendingTasksRequestParameters, ClusterPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_cluster/settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1851,13 +2199,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html</para>	
 		///</summary>
 		///<param name="body">The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart).</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterPutSettings<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterPutSettings<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_cluster/settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1866,13 +2217,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html</para>	
 		///</summary>
 		///<param name="body">The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart).</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterPutSettingsAsync<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterPutSettingsAsync<T>(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_cluster/settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1882,14 +2236,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html</para>	
 		///</summary>
 		///<param name="body">The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart).</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterPutSettings(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterPutSettings(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_cluster/settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1899,14 +2256,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-update-settings.html</para>	
 		///</summary>
 		///<param name="body">The settings to be updated. Can be either `transient` or `persistent` (survives cluster restart).</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterPutSettingsAsync(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterPutSettingsAsync(object body, Func<ClusterPutSettingsRequestParameters, ClusterPutSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cluster/reroute
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1915,13 +2275,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html</para>	
 		///</summary>
 		///<param name="body">The definition of `commands` to perform (`move`, `cancel`, `allocate`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterReroute<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterReroute<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cluster/reroute
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1930,13 +2293,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html</para>	
 		///</summary>
 		///<param name="body">The definition of `commands` to perform (`move`, `cancel`, `allocate`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterRerouteAsync<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterRerouteAsync<T>(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cluster/reroute
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -1946,14 +2312,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html</para>	
 		///</summary>
 		///<param name="body">The definition of `commands` to perform (`move`, `cancel`, `allocate`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterReroute(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterReroute(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cluster/reroute
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1963,14 +2332,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-reroute.html</para>	
 		///</summary>
 		///<param name="body">The definition of `commands` to perform (`move`, `cancel`, `allocate`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterRerouteAsync(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterRerouteAsync(object body, Func<ClusterRerouteRequestParameters, ClusterRerouteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1978,13 +2350,16 @@ public interface IElasticsearchClient
 		///<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/cluster-state.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterState<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterState<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1992,13 +2367,16 @@ public interface IElasticsearchClient
 		///<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/cluster-state.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterStateAsync<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2007,14 +2385,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-state.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterState(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterState(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2023,14 +2404,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-state.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStateAsync(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2039,13 +2423,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterState<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterState<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2054,13 +2441,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterStateAsync<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2070,14 +2460,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterState(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2087,14 +2480,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-state.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStateAsync(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2104,13 +2500,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterState<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterState<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}/{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2120,13 +2519,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterStateAsync<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2137,14 +2539,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterState(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/state/{metric}/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2155,14 +2560,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStateAsync(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string metric, string index, Func<ClusterStateRequestParameters, ClusterStateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2170,13 +2578,16 @@ public interface IElasticsearchClient
 		///<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/cluster-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterStats<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterStats<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2184,13 +2595,16 @@ public interface IElasticsearchClient
 		///<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/cluster-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterStatsAsync<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2199,14 +2613,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterStats(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterStats(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2215,14 +2632,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStatsAsync(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/stats/nodes/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2231,13 +2651,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ClusterStats<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ClusterStats<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/stats/nodes/{node_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2246,13 +2669,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ClusterStatsAsync<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/stats/nodes/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2262,14 +2688,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ClusterStats(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ClusterStats(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/stats/nodes/{node_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2279,14 +2708,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-stats.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ClusterStatsAsync(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(string node_id, Func<ClusterStatsRequestParameters, ClusterStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2295,13 +2727,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 		///</summary>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Count<T>(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Count<T>(object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2310,13 +2745,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 		///</summary>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountAsync<T>(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountAsync<T>(object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2326,14 +2764,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 		///</summary>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Count(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Count(object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2343,14 +2784,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 		///</summary>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountAsync(object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2360,13 +2804,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Count<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Count<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2376,13 +2823,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountAsync<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountAsync<T>(string index, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2393,14 +2843,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Count(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Count(string index, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2411,14 +2864,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountAsync(string index, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2429,13 +2885,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Count<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Count<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2446,13 +2905,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountAsync<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountAsync<T>(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2464,14 +2926,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Count(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Count(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2483,14 +2948,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
 		///<param name="body">A query to restrict the results specified with the Query DSL (optional)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountAsync(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, string type, object body, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2498,13 +2966,16 @@ public interface IElasticsearchClient
 		///<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/search-count.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CountGet<T>(Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountGet<T>(Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2512,13 +2983,16 @@ public interface IElasticsearchClient
 		///<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/search-count.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountGetAsync<T>(Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountGetAsync<T>(Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2527,14 +3001,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-count.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountGet(Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountGet(Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2543,14 +3020,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-count.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountGetAsync(Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2559,13 +3039,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CountGet<T>(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountGet<T>(string index, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2574,13 +3057,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountGetAsync<T>(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2590,14 +3076,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountGet(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountGet(string index, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2607,14 +3096,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-count.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountGetAsync(string index, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2624,13 +3116,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CountGet<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountGet<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2640,13 +3135,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountGetAsync<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, string type, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2657,14 +3155,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountGet(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountGet(string index, string type, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2675,14 +3176,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the results</param>
 		///<param name="type">A comma-separated list of types to restrict the results</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountGetAsync(string index, string type, Func<CountRequestParameters, CountRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index, string type, Func<CountRequestParameters, CountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2692,13 +3196,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CountPercolateGet<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2708,13 +3215,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountPercolateGetAsync<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2725,14 +3235,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountPercolateGet(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2743,14 +3256,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountPercolateGetAsync(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2761,13 +3277,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CountPercolateGet<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2778,13 +3297,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountPercolateGetAsync<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2796,14 +3318,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountPercolateGet(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2815,14 +3340,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountPercolateGetAsync(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(string index, string type, string id, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2833,13 +3361,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CountPercolate<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountPercolate<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2850,13 +3381,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountPercolateAsync<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2868,14 +3402,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountPercolate(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2887,14 +3424,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated.</param>
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountPercolateAsync(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2906,13 +3446,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> CountPercolate<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> CountPercolate<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2924,13 +3467,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> CountPercolateAsync<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -2943,14 +3489,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> CountPercolate(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -2963,14 +3512,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document being count percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The count percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> CountPercolateAsync(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string index, string type, string id, object body, Func<CountPercolateRequestParameters, CountPercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2981,13 +3533,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Delete<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Delete<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -2998,13 +3553,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> DeleteAsync<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> DeleteAsync<T>(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3016,14 +3574,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Delete(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Delete(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3035,14 +3596,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> DeleteAsync(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> DeleteAsync(string index, string type, string id, Func<DeleteRequestParameters, DeleteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3052,13 +3616,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> DeleteByQuery<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> DeleteByQuery<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3068,13 +3635,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> DeleteByQueryAsync<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3085,14 +3655,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> DeleteByQuery(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3103,14 +3676,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> DeleteByQueryAsync(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3121,13 +3697,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of types to restrict the operation</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> DeleteByQuery<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> DeleteByQuery<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3138,13 +3717,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of types to restrict the operation</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> DeleteByQueryAsync<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3156,14 +3738,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of types to restrict the operation</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> DeleteByQuery(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3175,14 +3760,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of indices to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of types to restrict the operation</param>
 		///<param name="body">A query to restrict the operation specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> DeleteByQueryAsync(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string index, string type, object body, Func<DeleteByQueryRequestParameters, DeleteByQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3193,13 +3781,16 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Exists<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Exists<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3210,13 +3801,16 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ExistsAsync<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ExistsAsync<T>(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3228,14 +3822,17 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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> Exists(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Exists(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3247,14 +3844,17 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ExistsAsync(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ExistsAsync(string index, string type, string id, Func<ExistsRequestParameters, ExistsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3265,13 +3865,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ExplainGet<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ExplainGet<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3282,13 +3885,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ExplainGetAsync<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ExplainGetAsync<T>(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3300,14 +3906,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ExplainGet(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ExplainGet(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3319,14 +3928,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ExplainGetAsync(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string index, string type, string id, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3338,13 +3950,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
 		///<param name="body">The query definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Explain<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Explain<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3356,13 +3971,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
 		///<param name="body">The query definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ExplainAsync<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ExplainAsync<T>(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3375,14 +3993,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
 		///<param name="body">The query definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Explain(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Explain(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_explain
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3395,14 +4016,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">The document ID</param>
 		///<param name="body">The query definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ExplainAsync(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ExplainAsync(string index, string type, string id, object body, Func<ExplainRequestParameters, ExplainRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3413,13 +4037,16 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Get<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Get<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3430,13 +4057,16 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> GetAsync<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> GetAsync<T>(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3448,14 +4078,17 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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> Get(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Get(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3467,14 +4100,17 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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>> GetAsync(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, string type, string id, Func<GetRequestParameters, GetRequestParameters> 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.
@@ -3485,13 +4121,16 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> GetSource<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> GetSource<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> requestParameters = null);
 		
 		///<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.
@@ -3502,13 +4141,16 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> GetSourceAsync<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> GetSourceAsync<T>(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_source
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3520,14 +4162,17 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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> GetSource(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> GetSource(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_source
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3539,14 +4184,17 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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>> GetSourceAsync(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string index, string type, string id, Func<SourceRequestParameters, SourceRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3557,13 +4205,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Index<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Index<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3574,13 +4225,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndexAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3592,14 +4246,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Index(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Index(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3611,14 +4268,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndexAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3630,13 +4290,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Index<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Index<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3648,13 +4311,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndexAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3667,14 +4333,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Index(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Index(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3687,14 +4356,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndexAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3705,13 +4377,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndexPut<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndexPut<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3722,13 +4397,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndexPutAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3740,14 +4418,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndexPut(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3759,14 +4440,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndexPutAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3778,13 +4462,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndexPut<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndexPut<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/{id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3796,13 +4483,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndexPutAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/{id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3815,14 +4505,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndexPut(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/{id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3835,14 +4528,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndexPutAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index, string type, string id, object body, Func<IndexRequestParameters, IndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3850,13 +4546,16 @@ public interface IElasticsearchClient
 		///<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/indices-analyze.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesAnalyzeGetForAll<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesAnalyzeGetForAll<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_analyze
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3864,13 +4563,16 @@ public interface IElasticsearchClient
 		///<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/indices-analyze.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesAnalyzeGetForAllAsync<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesAnalyzeGetForAllAsync<T>(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3879,14 +4581,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-analyze.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesAnalyzeGetForAll(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGetForAll(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_analyze
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3895,14 +4600,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-analyze.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesAnalyzeGetForAllAsync(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetForAllAsync(Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3911,13 +4619,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 		///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesAnalyzeGet<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesAnalyzeGet<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_analyze
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3926,13 +4637,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 		///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesAnalyzeGetAsync<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesAnalyzeGetAsync<T>(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -3942,14 +4656,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 		///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesAnalyzeGet(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGet(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_analyze
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -3959,14 +4676,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 		///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesAnalyzeGetAsync(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetAsync(string index, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3975,13 +4695,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 		///</summary>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesAnalyzeForAll<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesAnalyzeForAll<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_analyze
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -3990,13 +4713,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 		///</summary>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesAnalyzeForAllAsync<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesAnalyzeForAllAsync<T>(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4006,14 +4732,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 		///</summary>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesAnalyzeForAll(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeForAll(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_analyze
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4023,14 +4752,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-analyze.html</para>	
 		///</summary>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesAnalyzeForAllAsync(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeForAllAsync(object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4040,13 +4772,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesAnalyze<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesAnalyze<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_analyze
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4056,13 +4791,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesAnalyzeAsync<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesAnalyzeAsync<T>(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_analyze
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4073,14 +4811,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesAnalyze(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesAnalyze(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_analyze
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4091,14 +4832,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index to scope the operation</param>
 		///<param name="body">The text on which the analysis should be performed</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesAnalyzeAsync(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeAsync(string index, object body, Func<AnalyzeRequestParameters, AnalyzeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4106,13 +4850,16 @@ public interface IElasticsearchClient
 		///<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/indices-clearcache.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesClearCacheForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClearCacheForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cache/clear
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4120,13 +4867,16 @@ public interface IElasticsearchClient
 		///<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/indices-clearcache.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesClearCacheForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesClearCacheForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4135,14 +4885,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-clearcache.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClearCacheForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClearCacheForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cache/clear
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4151,14 +4904,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-clearcache.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesClearCacheForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4167,13 +4923,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesClearCache<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClearCache<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_cache/clear
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4182,13 +4941,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesClearCacheAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesClearCacheAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4198,14 +4960,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClearCache(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClearCache(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_cache/clear
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4215,14 +4980,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesClearCacheAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4230,13 +4998,16 @@ public interface IElasticsearchClient
 		///<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/indices-clearcache.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesClearCacheGetForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClearCacheGetForAll<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cache/clear
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4244,13 +5015,16 @@ public interface IElasticsearchClient
 		///<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/indices-clearcache.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesClearCacheGetForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesClearCacheGetForAllAsync<T>(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4259,14 +5033,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-clearcache.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClearCacheGetForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGetForAll(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cache/clear
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4275,14 +5052,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-clearcache.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesClearCacheGetForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetForAllAsync(Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4291,13 +5071,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesClearCacheGet<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClearCacheGet<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_cache/clear
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4306,13 +5089,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesClearCacheGetAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesClearCacheGetAsync<T>(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_cache/clear
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4322,14 +5108,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClearCacheGet(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGet(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_cache/clear
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4339,14 +5128,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-clearcache.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index name to limit the operation</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesClearCacheGetAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetAsync(string index, Func<ClearCacheRequestParameters, ClearCacheRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_close
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4355,13 +5147,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesClose<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesClose<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_close
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4370,13 +5165,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesCloseAsync<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesCloseAsync<T>(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_close
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4386,14 +5184,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesClose(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesClose(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_close
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4403,14 +5204,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesCloseAsync(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesCloseAsync(string index, Func<CloseIndexRequestParameters, CloseIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4420,13 +5224,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesCreate<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesCreate<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4436,13 +5243,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesCreateAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesCreateAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4453,14 +5263,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesCreate(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesCreate(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4471,14 +5284,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesCreateAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreateAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4488,13 +5304,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesCreatePost<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesCreatePost<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4504,13 +5323,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesCreatePostAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesCreatePostAsync<T>(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4521,14 +5343,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesCreatePost(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesCreatePost(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4539,14 +5364,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">The configuration for the index (`settings` and `mappings`)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesCreatePostAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreatePostAsync(string index, object body, Func<CreateIndexRequestParameters, CreateIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4555,13 +5383,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesDelete<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDelete<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4570,13 +5401,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesDeleteAsync<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteAsync<T>(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4586,14 +5420,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDelete(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDelete(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4603,14 +5440,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-delete-index.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to delete; use `_all` or `*` string to delete all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteAsync(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAsync(string index, Func<DeleteIndexRequestParameters, DeleteIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4620,13 +5460,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="name">A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesDeleteAlias<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDeleteAlias<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4636,13 +5479,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="name">A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesDeleteAliasAsync<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteAliasAsync<T>(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4653,14 +5499,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="name">A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDeleteAlias(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDeleteAlias(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4671,14 +5520,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="name">A comma-separated list of aliases to delete (supports wildcards); use `_all` to delete all aliases for the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteAliasAsync(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAliasAsync(string index, string name, Func<IndicesDeleteAliasRequestParameters, IndicesDeleteAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4688,13 +5540,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="type">A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesDeleteMapping<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDeleteMapping<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4704,13 +5559,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="type">A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesDeleteMappingAsync<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteMappingAsync<T>(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4721,14 +5579,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="type">A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDeleteMapping(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDeleteMapping(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/{type}/_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4739,14 +5600,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names (supports wildcards); use `_all` for all indices</param>
 		///<param name="type">A comma-separated list of document types to delete (supports wildcards); use `_all` to delete all document types in the specified indices.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteMappingAsync(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteMappingAsync(string index, string type, Func<DeleteMappingRequestParameters, DeleteMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4755,13 +5619,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesDeleteTemplateForAll<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDeleteTemplateForAll<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4770,13 +5637,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesDeleteTemplateForAllAsync<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteTemplateForAllAsync<T>(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4786,14 +5656,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDeleteTemplateForAll(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDeleteTemplateForAll(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4803,14 +5676,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteTemplateForAllAsync(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteTemplateForAllAsync(string name, Func<DeleteTemplateRequestParameters, DeleteTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4820,13 +5696,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices.</param>
 		///<param name="name">A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesDeleteWarmer<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesDeleteWarmer<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4836,13 +5715,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices.</param>
 		///<param name="name">A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesDeleteWarmerAsync<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesDeleteWarmerAsync<T>(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4853,14 +5735,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices.</param>
 		///<param name="name">A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesDeleteWarmer(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesDeleteWarmer(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /{index}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4871,14 +5756,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to delete warmers from (supports wildcards); use `_all` to perform the operation on all indices.</param>
 		///<param name="name">A comma-separated list of warmer names to delete (supports wildcards); use `_all` to delete all warmers in the specified indices. You must specify a name either in the uri or in the parameters.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesDeleteWarmerAsync(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteWarmerAsync(string index, string name, Func<DeleteWarmerRequestParameters, DeleteWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4887,13 +5775,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesExists<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExists<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4902,13 +5793,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesExistsAsync<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsAsync<T>(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4918,14 +5812,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExists(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExists(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4935,14 +5832,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-settings.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of indices to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsAsync(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAsync(string index, Func<IndexExistsRequestParameters, IndexExistsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4951,13 +5851,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesExistsAliasForAll<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsAliasForAll<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -4966,13 +5869,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesExistsAliasForAllAsync<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsAliasForAllAsync<T>(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -4982,14 +5888,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsAliasForAll(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsAliasForAll(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -4999,14 +5908,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsAliasForAllAsync(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasForAllAsync(string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5016,13 +5928,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesExistsAlias<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5032,13 +5947,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesExistsAliasAsync<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5049,14 +5967,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsAlias(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5067,14 +5988,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsAliasAsync(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, string name, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5083,13 +6007,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesExistsAlias<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5098,13 +6025,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesExistsAliasAsync<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5114,14 +6044,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsAlias(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/_alias
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5131,14 +6064,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsAliasAsync(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(string index, Func<IndicesExistsAliasRequestParameters, IndicesExistsAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5147,13 +6083,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesExistsTemplateForAll<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsTemplateForAll<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5162,13 +6101,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesExistsTemplateForAllAsync<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsTemplateForAllAsync<T>(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5178,14 +6120,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsTemplateForAll(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsTemplateForAll(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5195,14 +6140,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsTemplateForAllAsync(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTemplateForAllAsync(string name, Func<IndicesExistsTemplateRequestParameters, IndicesExistsTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5212,13 +6160,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` to check the types across all indices</param>
 		///<param name="type">A comma-separated list of document types to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesExistsType<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesExistsType<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5228,13 +6179,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` to check the types across all indices</param>
 		///<param name="type">A comma-separated list of document types to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesExistsTypeAsync<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesExistsTypeAsync<T>(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5245,14 +6199,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` to check the types across all indices</param>
 		///<param name="type">A comma-separated list of document types to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesExistsType(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesExistsType(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /{index}/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5263,14 +6220,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` to check the types across all indices</param>
 		///<param name="type">A comma-separated list of document types to check</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesExistsTypeAsync(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTypeAsync(string index, string type, Func<IndicesExistsTypeRequestParameters, IndicesExistsTypeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5278,13 +6238,16 @@ public interface IElasticsearchClient
 		///<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/indices-flush.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesFlushForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesFlushForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_flush
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5292,13 +6255,16 @@ public interface IElasticsearchClient
 		///<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/indices-flush.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesFlushForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesFlushForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5307,14 +6273,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-flush.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesFlushForAll(Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesFlushForAll(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_flush
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5323,14 +6292,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-flush.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesFlushForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5339,13 +6311,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesFlush<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesFlush<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_flush
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5354,13 +6329,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesFlushAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesFlushAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5370,14 +6348,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesFlush(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesFlush(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_flush
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5387,14 +6368,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesFlushAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5402,13 +6386,16 @@ public interface IElasticsearchClient
 		///<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/indices-flush.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesFlushGetForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesFlushGetForAll<T>(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_flush
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5416,13 +6403,16 @@ public interface IElasticsearchClient
 		///<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/indices-flush.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesFlushGetForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesFlushGetForAllAsync<T>(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5431,14 +6421,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-flush.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesFlushGetForAll(Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesFlushGetForAll(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_flush
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5447,14 +6440,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-flush.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesFlushGetForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetForAllAsync(Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5463,13 +6459,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesFlushGet<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesFlushGet<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_flush
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5478,13 +6477,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesFlushGetAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesFlushGetAsync<T>(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_flush
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5494,14 +6496,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesFlushGet(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesFlushGet(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_flush
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5511,14 +6516,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-flush.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesFlushGetAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetAsync(string index, Func<FlushRequestParameters, FlushRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5526,13 +6534,16 @@ public interface IElasticsearchClient
 		///<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/indices-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetAliasForAll<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliasForAll<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_alias
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5540,13 +6551,16 @@ public interface IElasticsearchClient
 		///<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/indices-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetAliasForAllAsync<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5555,14 +6569,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliasForAll(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_alias
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5571,14 +6588,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasForAllAsync(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5587,13 +6607,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetAliasForAll<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliasForAll<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5602,13 +6625,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetAliasForAllAsync<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5618,14 +6644,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliasForAll(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5635,14 +6664,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasForAllAsync(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync(string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5652,13 +6684,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetAlias<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAlias<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5668,13 +6703,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetAliasAsync<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5685,14 +6723,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAlias(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5703,14 +6744,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to return</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasAsync(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, string name, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5719,13 +6763,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetAlias<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAlias<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_alias
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5734,13 +6781,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetAliasAsync<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_alias
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5750,14 +6800,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAlias(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_alias
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5767,14 +6820,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasAsync(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(string index, Func<GetAliasesRequestParameters, GetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5782,13 +6838,16 @@ public interface IElasticsearchClient
 		///<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/indices-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetAliasesForAll<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_aliases
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5796,13 +6855,16 @@ public interface IElasticsearchClient
 		///<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/indices-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetAliasesForAllAsync<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5811,14 +6873,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliasesForAll(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_aliases
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5827,14 +6892,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-aliases.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasesForAllAsync(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5843,13 +6911,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetAliases<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliases<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5858,13 +6929,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetAliasesAsync<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5874,14 +6948,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliases(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5891,14 +6968,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasesAsync(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5908,13 +6988,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetAliases<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliases<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5924,13 +7007,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetAliasesAsync<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -5941,14 +7027,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliases(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_aliases/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -5959,14 +7048,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to filter aliases</param>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasesAsync(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(string index, string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5975,13 +7067,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetAliasesForAll<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_aliases/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -5990,13 +7085,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetAliasesForAllAsync<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6006,14 +7104,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetAliasesForAll(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_aliases/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6023,14 +7124,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="name">A comma-separated list of alias names to filter</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetAliasesForAllAsync(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsync(string name, Func<IndicesGetAliasesRequestParameters, IndicesGetAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6039,13 +7143,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html</para>	
 		///</summary>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetFieldMappingForAll<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/field/{field}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6054,13 +7161,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html</para>	
 		///</summary>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetFieldMappingForAllAsync<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6070,14 +7180,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html</para>	
 		///</summary>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetFieldMappingForAll(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/field/{field}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6087,14 +7200,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-field-mapping.html</para>	
 		///</summary>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetFieldMappingForAllAsync(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6104,13 +7220,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetFieldMapping<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/field/{field}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6120,13 +7239,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetFieldMappingAsync<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6137,14 +7259,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetFieldMapping(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/field/{field}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6155,14 +7280,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetFieldMappingAsync(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6172,13 +7300,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetFieldMappingForAll<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}/field/{field}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6188,13 +7319,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetFieldMappingForAllAsync<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6205,14 +7339,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetFieldMappingForAll(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}/field/{field}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6223,14 +7360,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetFieldMappingForAllAsync(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForAllAsync(string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6241,13 +7381,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetFieldMapping<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}/field/{field}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6258,13 +7401,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetFieldMappingAsync<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}/field/{field}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6276,14 +7422,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetFieldMapping(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}/field/{field}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6295,14 +7444,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
 		///<param name="field">A comma-separated list of fields</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetFieldMappingAsync(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsync(string index, string type, string field, Func<IndicesGetFieldMappingRequestParameters, IndicesGetFieldMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6310,13 +7462,16 @@ public interface IElasticsearchClient
 		///<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/indices-get-mapping.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetMappingForAll<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetMappingForAll<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6324,13 +7479,16 @@ public interface IElasticsearchClient
 		///<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/indices-get-mapping.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetMappingForAllAsync<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6339,14 +7497,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-get-mapping.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetMappingForAll(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6355,14 +7516,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-get-mapping.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetMappingForAllAsync(Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6371,13 +7535,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetMapping<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetMapping<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6386,13 +7553,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetMappingAsync<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6402,14 +7572,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetMapping(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6419,14 +7592,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetMappingAsync(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6435,13 +7611,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetMappingForAll<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetMappingForAll<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6450,13 +7629,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetMappingForAllAsync<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6466,14 +7648,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetMappingForAll(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mapping/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6483,14 +7668,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetMappingForAllAsync(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsync(string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6500,13 +7688,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetMapping<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetMapping<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6516,13 +7707,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetMappingAsync<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6533,14 +7727,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetMapping(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mapping/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6551,14 +7748,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names</param>
 		///<param name="type">A comma-separated list of document types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetMappingAsync(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(string index, string type, Func<GetMappingRequestParameters, GetMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6566,13 +7766,16 @@ public interface IElasticsearchClient
 		///<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/indices-get-mapping.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetSettingsForAll<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6580,13 +7783,16 @@ public interface IElasticsearchClient
 		///<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/indices-get-mapping.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetSettingsForAllAsync<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6595,14 +7801,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-get-mapping.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetSettingsForAll(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6611,14 +7820,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-get-mapping.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetSettingsForAllAsync(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6627,13 +7839,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetSettings<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetSettings<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6642,13 +7857,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetSettingsAsync<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6658,14 +7876,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetSettings(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6675,14 +7896,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetSettingsAsync(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_settings/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6692,13 +7916,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetSettings<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetSettings<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_settings/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6708,13 +7935,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetSettingsAsync<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_settings/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6725,14 +7955,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetSettings(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_settings/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6743,14 +7976,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetSettingsAsync(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(string index, string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_settings/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6759,13 +7995,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetSettingsForAll<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_settings/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6774,13 +8013,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetSettingsForAllAsync<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_settings/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6790,14 +8032,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetSettingsForAll(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_settings/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6807,14 +8052,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-get-mapping.html</para>	
 		///</summary>
 		///<param name="name">The name of the settings that should be included</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetSettingsForAllAsync(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAsync(string name, Func<GetIndexSettingsRequestParameters, GetIndexSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_template
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6822,13 +8070,16 @@ public interface IElasticsearchClient
 		///<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/indices-templates.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetTemplateForAll<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_template
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6836,13 +8087,16 @@ public interface IElasticsearchClient
 		///<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/indices-templates.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetTemplateForAllAsync<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_template
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6851,14 +8105,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-templates.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetTemplateForAll(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_template
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6867,14 +8124,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-templates.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetTemplateForAllAsync(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6883,13 +8143,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetTemplateForAll<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6898,13 +8161,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetTemplateForAllAsync<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6914,14 +8180,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetTemplateForAll(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6931,14 +8200,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-templates.html</para>	
 		///</summary>
 		///<param name="name">The name of the template</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetTemplateForAllAsync(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAsync(string name, Func<GetTemplateRequestParameters, GetTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_warmer
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6946,13 +8218,16 @@ public interface IElasticsearchClient
 		///<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/indices-warmers.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetWarmerForAll<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_warmer
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -6960,13 +8235,16 @@ public interface IElasticsearchClient
 		///<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/indices-warmers.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetWarmerForAllAsync<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_warmer
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -6975,14 +8253,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-warmers.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmerForAll(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_warmer
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -6991,14 +8272,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-warmers.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerForAllAsync(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7007,13 +8291,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetWarmer<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7022,13 +8309,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetWarmerAsync<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7038,14 +8328,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmer(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7055,14 +8348,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerAsync(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7072,13 +8368,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetWarmer<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7088,13 +8387,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetWarmerAsync<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7105,14 +8407,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmer(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7123,14 +8428,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerAsync(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7139,13 +8447,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 		///</summary>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetWarmerForAll<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7154,13 +8465,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 		///</summary>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetWarmerForAllAsync<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7170,14 +8484,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 		///</summary>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmerForAll(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7187,14 +8504,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-warmers.html</para>	
 		///</summary>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerForAllAsync(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsync(string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7205,13 +8525,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesGetWarmer<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7222,13 +8545,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesGetWarmerAsync<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7240,14 +8566,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesGetWarmer(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7259,14 +8588,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer (supports wildcards); leave empty to get all warmers</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesGetWarmerAsync(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(string index, string type, string name, Func<GetWarmerRequestParameters, GetWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_open
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7275,13 +8607,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesOpen<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOpen<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_open
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7290,13 +8625,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesOpenAsync<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOpenAsync<T>(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_open
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7306,14 +8644,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOpen(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOpen(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_open
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7323,14 +8664,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-open-close.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOpenAsync(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOpenAsync(string index, Func<OpenIndexRequestParameters, OpenIndexRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7338,13 +8682,16 @@ public interface IElasticsearchClient
 		///<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/indices-optimize.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesOptimizeForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOptimizeForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_optimize
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7352,13 +8699,16 @@ public interface IElasticsearchClient
 		///<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/indices-optimize.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesOptimizeForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOptimizeForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7367,14 +8717,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-optimize.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOptimizeForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOptimizeForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_optimize
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7383,14 +8736,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-optimize.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOptimizeForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7399,13 +8755,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesOptimize<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOptimize<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_optimize
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7414,13 +8773,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesOptimizeAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOptimizeAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7430,14 +8792,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOptimize(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOptimize(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_optimize
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7447,14 +8812,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOptimizeAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7462,13 +8830,16 @@ public interface IElasticsearchClient
 		///<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/indices-optimize.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesOptimizeGetForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOptimizeGetForAll<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_optimize
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7476,13 +8847,16 @@ public interface IElasticsearchClient
 		///<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/indices-optimize.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesOptimizeGetForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOptimizeGetForAllAsync<T>(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7491,14 +8865,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-optimize.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOptimizeGetForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGetForAll(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_optimize
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7507,14 +8884,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-optimize.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOptimizeGetForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetForAllAsync(Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7523,13 +8903,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesOptimizeGet<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesOptimizeGet<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_optimize
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7538,13 +8921,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesOptimizeGetAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesOptimizeGetAsync<T>(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_optimize
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7554,14 +8940,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesOptimizeGet(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGet(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_optimize
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7571,14 +8960,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-optimize.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesOptimizeGetAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetAsync(string index, Func<OptimizeRequestParameters, OptimizeRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7589,13 +8981,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutAlias<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutAlias<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7606,13 +9001,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutAliasAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutAliasAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7624,14 +9022,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutAlias(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutAlias(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7643,14 +9044,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutAliasAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7660,13 +9064,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutAliasForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutAliasForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7676,13 +9083,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutAliasForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutAliasForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7693,14 +9103,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutAliasForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutAliasForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7711,14 +9124,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutAliasForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7729,13 +9145,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutAliasPost<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutAliasPost<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7746,13 +9165,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutAliasPostAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutAliasPostAsync<T>(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7764,14 +9186,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutAliasPost(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPost(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7783,14 +9208,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the alias should point to (supports wildcards); use `_all` or omit to perform the operation on all indices.</param>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutAliasPostAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostAsync(string index, string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7800,13 +9228,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutAliasPostForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutAliasPostForAll<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_alias/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7816,13 +9247,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutAliasPostForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutAliasPostForAllAsync<T>(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_alias/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7833,14 +9267,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutAliasPostForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPostForAll(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_alias/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7851,14 +9288,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the alias to be created or updated</param>
 		///<param name="body">The settings for the alias, such as `routing` or `filter`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutAliasPostForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostForAllAsync(string name, object body, Func<IndicesPutAliasRequestParameters, IndicesPutAliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7869,13 +9309,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutMapping<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutMapping<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7886,13 +9329,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutMappingAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutMappingAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7904,14 +9350,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutMapping(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutMapping(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7923,14 +9372,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutMappingAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7940,13 +9392,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutMappingForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutMappingForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_mapping/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -7956,13 +9411,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutMappingForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutMappingForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -7973,14 +9431,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutMappingForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutMappingForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_mapping/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -7991,14 +9452,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutMappingForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8009,13 +9473,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutMappingPost<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutMappingPost<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mapping
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8026,13 +9493,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutMappingPostAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutMappingPostAsync<T>(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mapping
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8044,14 +9514,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutMappingPost(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPost(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mapping
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8063,14 +9536,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names the mapping should be added to (supports wildcards); use `_all` or omit to add the mapping on all indices.</param>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutMappingPostAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostAsync(string index, string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8080,13 +9556,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutMappingPostForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutMappingPostForAll<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mapping/{type}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8096,13 +9575,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutMappingPostForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutMappingPostForAllAsync<T>(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mapping/{type}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8113,14 +9595,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutMappingPostForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPostForAll(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mapping/{type}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8131,14 +9616,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="type">The name of the document type</param>
 		///<param name="body">The mapping definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutMappingPostForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostForAllAsync(string type, object body, Func<PutMappingRequestParameters, PutMappingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8147,13 +9635,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html</para>	
 		///</summary>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutSettingsForAll<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutSettingsForAll<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8162,13 +9653,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html</para>	
 		///</summary>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutSettingsForAllAsync<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutSettingsForAllAsync<T>(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8178,14 +9672,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html</para>	
 		///</summary>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutSettingsForAll(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutSettingsForAll(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8195,14 +9692,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-update-settings.html</para>	
 		///</summary>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutSettingsForAllAsync(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsForAllAsync(object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8212,13 +9712,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutSettings<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutSettings<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_settings
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8228,13 +9731,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutSettingsAsync<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutSettingsAsync<T>(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_settings
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8245,14 +9751,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutSettings(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutSettings(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_settings
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8263,14 +9772,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The index settings to be updated</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutSettingsAsync(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsAsync(string index, object body, Func<UpdateSettingsRequestParameters, UpdateSettingsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8280,13 +9792,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutTemplateForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutTemplateForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8296,13 +9811,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutTemplateForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutTemplateForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8313,14 +9831,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutTemplateForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutTemplateForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8331,14 +9852,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutTemplateForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplateForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8348,13 +9872,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutTemplatePostForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutTemplatePostForAll<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_template/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8364,13 +9891,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutTemplatePostForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutTemplatePostForAllAsync<T>(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_template/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8381,14 +9911,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutTemplatePostForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutTemplatePostForAll(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_template/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8399,14 +9932,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the template</param>
 		///<param name="body">The template definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutTemplatePostForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplatePostForAllAsync(string name, object body, Func<PutTemplateRequestParameters, PutTemplateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8416,13 +9952,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutWarmerForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmerForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8432,13 +9971,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutWarmerForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8449,14 +9991,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmerForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8467,14 +10012,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8485,13 +10033,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutWarmer<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8502,13 +10053,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutWarmerAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8520,14 +10074,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmer(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8539,14 +10096,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8558,13 +10118,16 @@ public interface IElasticsearchClient
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutWarmer<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8576,13 +10139,16 @@ public interface IElasticsearchClient
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutWarmerAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8595,14 +10161,17 @@ public interface IElasticsearchClient
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmer(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8615,14 +10184,17 @@ public interface IElasticsearchClient
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8632,13 +10204,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutWarmerPostForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmerPostForAll<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8648,13 +10223,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutWarmerPostForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerPostForAllAsync<T>(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8665,14 +10243,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmerPostForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPostForAll(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8683,14 +10264,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerPostForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostForAllAsync(string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8701,13 +10285,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutWarmerPost<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8718,13 +10305,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutWarmerPostAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8736,14 +10326,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmerPost(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8755,14 +10348,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to register the warmer for; use `_all` or omit to perform the operation on all indices</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerPostAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8774,13 +10370,16 @@ public interface IElasticsearchClient
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesPutWarmerPost<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8792,13 +10391,16 @@ public interface IElasticsearchClient
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesPutWarmerPostAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8811,14 +10413,17 @@ public interface IElasticsearchClient
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesPutWarmerPost(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_warmer/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8831,14 +10436,17 @@ public interface IElasticsearchClient
 		///<param name="type">A comma-separated list of document types to register the warmer for; leave empty to perform the operation on all types</param>
 		///<param name="name">The name of the warmer</param>
 		///<param name="body">The search request definition for the warmer (query, filters, facets, sorting, etc)</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesPutWarmerPostAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(string index, string type, string name, object body, Func<PutWarmerRequestParameters, PutWarmerRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8846,13 +10454,16 @@ public interface IElasticsearchClient
 		///<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/indices-refresh.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesRefreshForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesRefreshForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_refresh
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8860,13 +10471,16 @@ public interface IElasticsearchClient
 		///<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/indices-refresh.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesRefreshForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesRefreshForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8875,14 +10489,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-refresh.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesRefreshForAll(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesRefreshForAll(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_refresh
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8891,14 +10508,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-refresh.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesRefreshForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8907,13 +10527,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesRefresh<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesRefresh<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_refresh
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8922,13 +10545,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesRefreshAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesRefreshAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8938,14 +10564,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesRefresh(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesRefresh(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_refresh
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -8955,14 +10584,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesRefreshAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8970,13 +10602,16 @@ public interface IElasticsearchClient
 		///<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/indices-refresh.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesRefreshGetForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesRefreshGetForAll<T>(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_refresh
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -8984,13 +10619,16 @@ public interface IElasticsearchClient
 		///<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/indices-refresh.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesRefreshGetForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesRefreshGetForAllAsync<T>(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -8999,14 +10637,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-refresh.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesRefreshGetForAll(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesRefreshGetForAll(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_refresh
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9015,14 +10656,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-refresh.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesRefreshGetForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetForAllAsync(Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9031,13 +10675,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesRefreshGet<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesRefreshGet<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_refresh
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9046,13 +10693,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesRefreshGetAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesRefreshGetAsync<T>(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_refresh
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9062,14 +10712,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesRefreshGet(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesRefreshGet(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_refresh
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9079,14 +10732,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-refresh.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesRefreshGetAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetAsync(string index, Func<RefreshRequestParameters, RefreshRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_segments
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9094,13 +10750,16 @@ public interface IElasticsearchClient
 		///<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/indices-segments.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesSegmentsForAll<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesSegmentsForAll<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_segments
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9108,13 +10767,16 @@ public interface IElasticsearchClient
 		///<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/indices-segments.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesSegmentsForAllAsync<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesSegmentsForAllAsync<T>(Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_segments
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9123,14 +10785,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-segments.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesSegmentsForAll(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesSegmentsForAll(Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_segments
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9139,14 +10804,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-segments.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesSegmentsForAllAsync(Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsForAllAsync(Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_segments
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9155,13 +10823,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesSegments<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesSegments<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_segments
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9170,13 +10841,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesSegmentsAsync<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesSegmentsAsync<T>(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_segments
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9186,14 +10860,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesSegments(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesSegments(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_segments
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9203,14 +10880,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-segments.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesSegmentsAsync(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsAsync(string index, Func<SegmentsRequestParameters, SegmentsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_gateway/snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9218,13 +10898,16 @@ public interface IElasticsearchClient
 		///<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/indices-gateway-snapshot.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesSnapshotIndexForAll<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesSnapshotIndexForAll<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_gateway/snapshot
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9232,13 +10915,16 @@ public interface IElasticsearchClient
 		///<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/indices-gateway-snapshot.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesSnapshotIndexForAllAsync<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesSnapshotIndexForAllAsync<T>(Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_gateway/snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9247,14 +10933,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-gateway-snapshot.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesSnapshotIndexForAll(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndexForAll(Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_gateway/snapshot
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9263,14 +10952,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-gateway-snapshot.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesSnapshotIndexForAllAsync(Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexForAllAsync(Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_gateway/snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9279,13 +10971,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesSnapshotIndex<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesSnapshotIndex<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_gateway/snapshot
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9294,13 +10989,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesSnapshotIndexAsync<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesSnapshotIndexAsync<T>(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_gateway/snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9310,14 +11008,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesSnapshotIndex(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndex(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_gateway/snapshot
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9327,14 +11028,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-gateway-snapshot.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string for all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesSnapshotIndexAsync(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexAsync(string index, Func<SnapshotRequestParameters, SnapshotRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9342,13 +11046,16 @@ public interface IElasticsearchClient
 		///<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/indices-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesStatsForAll<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStatsForAll<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9356,13 +11063,16 @@ public interface IElasticsearchClient
 		///<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/indices-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesStatsForAllAsync<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9371,14 +11081,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStatsForAll(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9387,14 +11100,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatsForAllAsync(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9403,13 +11119,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesStatsForAll<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStatsForAll<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_stats/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9418,13 +11137,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesStatsForAllAsync<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9434,14 +11156,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStatsForAll(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_stats/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9451,14 +11176,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatsForAllAsync(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9467,13 +11195,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesStats<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStats<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9482,13 +11213,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesStatsAsync<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9498,14 +11232,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStats(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9515,14 +11252,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-stats.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatsAsync(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9532,13 +11272,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesStats<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_stats/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9548,13 +11291,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesStatsAsync<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9565,14 +11311,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStats(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_stats/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9583,14 +11332,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="metric">Limit the information returned the specific metrics.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatsAsync(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string index, string metric, Func<IndicesStatsRequestParameters, IndicesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_status
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9598,13 +11350,16 @@ public interface IElasticsearchClient
 		///<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/indices-status.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesStatusForAll<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStatusForAll<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_status
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9612,13 +11367,16 @@ public interface IElasticsearchClient
 		///<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/indices-status.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesStatusForAllAsync<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatusForAllAsync<T>(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_status
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9627,14 +11385,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-status.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStatusForAll(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStatusForAll(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_status
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9643,14 +11404,17 @@ public interface IElasticsearchClient
 		///<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/1.x/indices-status.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatusForAllAsync(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusForAllAsync(Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_status
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9659,13 +11423,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesStatus<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesStatus<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_status
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9674,13 +11441,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesStatusAsync<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesStatusAsync<T>(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_status
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9690,14 +11460,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesStatus(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesStatus(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_status
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9707,14 +11480,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-status.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesStatusAsync(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusAsync(string index, Func<IndicesStatusRequestParameters, IndicesStatusRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9723,13 +11499,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="body">The definition of `actions` to perform</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesUpdateAliasesForAll<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesUpdateAliasesForAll<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_aliases
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9738,13 +11517,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="body">The definition of `actions` to perform</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesUpdateAliasesForAllAsync<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesUpdateAliasesForAllAsync<T>(object body, Func<AliasRequestParameters, AliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_aliases
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9754,14 +11536,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="body">The definition of `actions` to perform</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesUpdateAliasesForAll(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesUpdateAliasesForAll(object body, Func<AliasRequestParameters, AliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_aliases
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9771,14 +11556,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/indices-aliases.html</para>	
 		///</summary>
 		///<param name="body">The definition of `actions` to perform</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesUpdateAliasesForAllAsync(object body, Func<AliasRequestParameters, AliasRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesUpdateAliasesForAllAsync(object body, Func<AliasRequestParameters, AliasRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9786,13 +11574,16 @@ public interface IElasticsearchClient
 		///<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/search-validate.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesValidateQueryGetForAll<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQueryGetForAll<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9800,13 +11591,16 @@ public interface IElasticsearchClient
 		///<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/search-validate.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesValidateQueryGetForAllAsync<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryGetForAllAsync<T>(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9815,14 +11609,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-validate.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQueryGetForAll(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGetForAll(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9831,14 +11628,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-validate.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryGetForAllAsync(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetForAllAsync(Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9847,13 +11647,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesValidateQueryGet<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9862,13 +11665,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesValidateQueryGetAsync<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9878,14 +11684,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQueryGet(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9895,14 +11704,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryGetAsync(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9912,13 +11724,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesValidateQueryGet<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9928,13 +11743,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesValidateQueryGetAsync<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -9945,14 +11763,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQueryGet(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -9963,14 +11784,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryGetAsync(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsync(string index, string type, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9979,13 +11803,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 		///</summary>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesValidateQueryForAll<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQueryForAll<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -9994,13 +11821,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 		///</summary>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesValidateQueryForAllAsync<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryForAllAsync<T>(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10010,14 +11840,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 		///</summary>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQueryForAll(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryForAll(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10027,14 +11860,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-validate.html</para>	
 		///</summary>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryForAllAsync(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryForAllAsync(object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10044,13 +11880,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesValidateQuery<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10060,13 +11899,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesValidateQueryAsync<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10077,14 +11919,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQuery(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10095,14 +11940,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryAsync(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10113,13 +11961,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> IndicesValidateQuery<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_validate/query
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10130,13 +11981,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> IndicesValidateQueryAsync<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_validate/query
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10148,14 +12002,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> IndicesValidateQuery(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_validate/query
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10167,14 +12024,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to restrict the operation; leave empty to perform the operation on all types</param>
 		///<param name="body">The query definition specified with the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> IndicesValidateQueryAsync(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(string index, string type, object body, Func<ValidateQueryRequestParameters, ValidateQueryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10182,13 +12042,16 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///<para>See also: http://www.elasticsearch.org/guide/</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Info<T>(Func<InfoRequestParameters, InfoRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Info<T>(Func<InfoRequestParameters, InfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10196,13 +12059,16 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///<para>See also: http://www.elasticsearch.org/guide/</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> InfoAsync<T>(Func<InfoRequestParameters, InfoRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> InfoAsync<T>(Func<InfoRequestParameters, InfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10211,14 +12077,17 @@ public interface IElasticsearchClient
 		///<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/</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Info(Func<InfoRequestParameters, InfoRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Info(Func<InfoRequestParameters, InfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10227,14 +12096,17 @@ public interface IElasticsearchClient
 		///<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/</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> InfoAsync(Func<InfoRequestParameters, InfoRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> InfoAsync(Func<InfoRequestParameters, InfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10242,13 +12114,16 @@ public interface IElasticsearchClient
 		///<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-multi-get.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MgetGet<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MgetGet<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10256,13 +12131,16 @@ public interface IElasticsearchClient
 		///<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-multi-get.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MgetGetAsync<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetGetAsync<T>(Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10271,14 +12149,17 @@ public interface IElasticsearchClient
 		///<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/1.x/docs-multi-get.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MgetGet(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MgetGet(Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10287,14 +12168,17 @@ public interface IElasticsearchClient
 		///<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/1.x/docs-multi-get.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetGetAsync(Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10303,13 +12187,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MgetGet<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MgetGet<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10318,13 +12205,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MgetGetAsync<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10334,14 +12224,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MgetGet(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MgetGet(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10351,14 +12244,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 		///</summary>
 		///<param name="index">The name of the index</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetGetAsync(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10368,13 +12264,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MgetGet<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MgetGet<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10384,13 +12283,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MgetGetAsync<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10401,14 +12303,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MgetGet(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MgetGet(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10419,14 +12324,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetGetAsync(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index, string type, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10435,13 +12343,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 		///</summary>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mget<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mget<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10450,13 +12361,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 		///</summary>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MgetAsync<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetAsync<T>(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10466,14 +12380,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 		///</summary>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mget(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mget(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10483,14 +12400,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-get.html</para>	
 		///</summary>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetAsync(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10500,13 +12420,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mget<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mget<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10516,13 +12439,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MgetAsync<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10533,14 +12459,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mget(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mget(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10551,14 +12480,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The name of the index</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetAsync(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10569,13 +12501,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mget<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mget<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mget
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10586,13 +12521,16 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MgetAsync<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mget
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10604,14 +12542,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mget(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mget(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mget
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10623,14 +12564,17 @@ public interface IElasticsearchClient
 		///<param name="index">The name of the index</param>
 		///<param name="type">The type of the document</param>
 		///<param name="body">Document identifiers; can be either `docs` (containing full document information) or `ids` (when index and type is provided in the URL.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MgetAsync(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, string type, object body, Func<MultiGetRequestParameters, MultiGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10641,13 +12585,16 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MltGet<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MltGet<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10658,13 +12605,16 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MltGetAsync<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MltGetAsync<T>(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10676,14 +12626,17 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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> MltGet(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MltGet(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10695,14 +12648,17 @@ public interface IElasticsearchClient
 		///<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="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MltGetAsync(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MltGetAsync(string index, string type, string id, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10714,13 +12670,16 @@ public interface IElasticsearchClient
 		///<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="body">A specific search request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mlt<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mlt<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10732,13 +12691,16 @@ public interface IElasticsearchClient
 		///<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="body">A specific search request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MltAsync<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MltAsync<T>(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10751,14 +12713,17 @@ public interface IElasticsearchClient
 		///<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="body">A specific search request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mlt(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mlt(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_mlt
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10771,14 +12736,17 @@ public interface IElasticsearchClient
 		///<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="body">A specific search request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MltAsync(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MltAsync(string index, string type, string id, object body, Func<MoreLikeThisRequestParameters, MoreLikeThisRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10786,13 +12754,16 @@ public interface IElasticsearchClient
 		///<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/search-percolate.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MpercolateGet<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MpercolateGet<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10800,13 +12771,16 @@ public interface IElasticsearchClient
 		///<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/search-percolate.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MpercolateGetAsync<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10815,14 +12789,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-percolate.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MpercolateGet(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MpercolateGet(Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10831,14 +12808,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-percolate.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateGetAsync(Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10847,13 +12827,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MpercolateGet<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MpercolateGet<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10862,13 +12845,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MpercolateGetAsync<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10878,14 +12864,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MpercolateGet(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10895,14 +12884,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateGetAsync(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10912,13 +12904,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MpercolateGet<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MpercolateGet<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10928,13 +12923,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MpercolateGetAsync<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -10945,14 +12943,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MpercolateGet(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -10963,14 +12964,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateGetAsync(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string index, string type, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10979,13 +12983,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 		///</summary>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mpercolate<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mpercolate<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -10994,13 +13001,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 		///</summary>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MpercolateAsync<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateAsync<T>(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11010,14 +13020,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 		///</summary>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mpercolate(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mpercolate(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11027,14 +13040,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-percolate.html</para>	
 		///</summary>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateAsync(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11044,13 +13060,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mpercolate<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mpercolate<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11060,13 +13079,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MpercolateAsync<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11077,14 +13099,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mpercolate(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11095,14 +13120,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateAsync(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11113,13 +13141,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mpercolate<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mpercolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11130,13 +13161,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MpercolateAsync<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mpercolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11148,14 +13182,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mpercolate(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mpercolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11167,14 +13204,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being count percolated to use as default</param>
 		///<param name="type">The type of the document being percolated to use as default.</param>
 		///<param name="body">The percolate request definitions (header &amp; body pair), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MpercolateAsync(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string index, string type, object body, Func<MpercolateRequestParameters, MpercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11182,13 +13222,16 @@ public interface IElasticsearchClient
 		///<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/search-multi-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MsearchGet<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MsearchGet<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11196,13 +13239,16 @@ public interface IElasticsearchClient
 		///<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/search-multi-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MsearchGetAsync<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11211,14 +13257,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-multi-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MsearchGet(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MsearchGet(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11227,14 +13276,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-multi-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchGetAsync(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11243,13 +13295,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MsearchGet<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MsearchGet<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11258,13 +13313,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MsearchGetAsync<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11274,14 +13332,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MsearchGet(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11291,14 +13352,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchGetAsync(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11308,13 +13372,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MsearchGet<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11324,13 +13391,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MsearchGetAsync<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11341,14 +13411,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MsearchGet(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11359,14 +13432,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchGetAsync(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string index, string type, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11375,13 +13451,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 		///</summary>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Msearch<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Msearch<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11390,13 +13469,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 		///</summary>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MsearchAsync<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchAsync<T>(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11406,14 +13488,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 		///</summary>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Msearch(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Msearch(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11423,14 +13508,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-multi-search.html</para>	
 		///</summary>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchAsync(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11440,13 +13528,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Msearch<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Msearch<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11456,13 +13547,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MsearchAsync<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11473,14 +13567,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Msearch(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Msearch(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11491,14 +13588,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchAsync(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11509,13 +13609,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Msearch<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Msearch<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_msearch
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11526,13 +13629,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MsearchAsync<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_msearch
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11544,14 +13650,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Msearch(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Msearch(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_msearch
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11563,14 +13672,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to use as default</param>
 		///<param name="type">A comma-separated list of document types to use as default</param>
 		///<param name="body">The request definitions (metadata-search request definition pairs), separated by newlines</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MsearchAsync(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index, string type, object body, Func<MultiSearchRequestParameters, MultiSearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11578,13 +13690,16 @@ public interface IElasticsearchClient
 		///<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-multi-termvectors.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MtermvectorsGet<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MtermvectorsGet<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11592,13 +13707,16 @@ public interface IElasticsearchClient
 		///<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-multi-termvectors.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MtermvectorsGetAsync<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11607,14 +13725,17 @@ public interface IElasticsearchClient
 		///<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/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MtermvectorsGet(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11623,14 +13744,17 @@ public interface IElasticsearchClient
 		///<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/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsGetAsync(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11639,13 +13763,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MtermvectorsGet<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MtermvectorsGet<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11654,13 +13781,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MtermvectorsGetAsync<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11670,14 +13800,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MtermvectorsGet(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11687,14 +13820,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsGetAsync(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11704,13 +13840,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> MtermvectorsGet<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11720,13 +13859,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MtermvectorsGetAsync<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11737,14 +13879,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> MtermvectorsGet(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11755,14 +13900,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsGetAsync(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(string index, string type, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11771,13 +13919,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mtermvectors<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mtermvectors<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11786,13 +13937,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MtermvectorsAsync<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11802,14 +13956,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mtermvectors(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mtermvectors(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11819,14 +13976,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/docs-multi-termvectors.html</para>	
 		///</summary>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsAsync(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11836,13 +13996,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mtermvectors<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mtermvectors<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11852,13 +14015,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MtermvectorsAsync<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11869,14 +14035,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mtermvectors(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11887,14 +14056,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsAsync(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11905,13 +14077,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Mtermvectors<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11922,13 +14097,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> MtermvectorsAsync<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -11940,14 +14118,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Mtermvectors(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_mtermvectors
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -11959,14 +14140,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="body">Define ids, parameters or a list of parameters per document here. You must at least provide a list of document ids. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> MtermvectorsAsync(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string index, string type, object body, Func<MtermvectorsRequestParameters, MtermvectorsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/hotthreads
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11974,13 +14158,16 @@ public interface IElasticsearchClient
 		///<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/cluster-nodes-hot-threads.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesHotThreadsForAll<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesHotThreadsForAll<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/hotthreads
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -11988,13 +14175,16 @@ public interface IElasticsearchClient
 		///<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/cluster-nodes-hot-threads.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesHotThreadsForAllAsync<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesHotThreadsForAllAsync<T>(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/hotthreads
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12003,14 +14193,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-nodes-hot-threads.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesHotThreadsForAll(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesHotThreadsForAll(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/hotthreads
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12019,14 +14212,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-nodes-hot-threads.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesHotThreadsForAllAsync(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsForAllAsync(Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/{node_id}/hotthreads
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12035,13 +14231,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesHotThreads<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesHotThreads<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/{node_id}/hotthreads
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12050,13 +14249,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesHotThreadsAsync<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesHotThreadsAsync<T>(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/{node_id}/hotthreads
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12066,14 +14268,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesHotThreads(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesHotThreads(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cluster/nodes/{node_id}/hotthreads
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12083,14 +14288,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-hot-threads.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesHotThreadsAsync(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsAsync(string node_id, Func<NodesHotThreadsRequestParameters, NodesHotThreadsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12098,13 +14306,16 @@ public interface IElasticsearchClient
 		///<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/cluster-nodes-info.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesInfoForAll<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesInfoForAll<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12112,13 +14323,16 @@ public interface IElasticsearchClient
 		///<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/cluster-nodes-info.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesInfoForAllAsync<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12127,14 +14341,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-nodes-info.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesInfoForAll(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12143,14 +14360,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-nodes-info.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesInfoForAllAsync(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12159,13 +14379,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesInfo<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesInfo<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12174,13 +14397,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesInfoAsync<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12190,14 +14416,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesInfo(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12207,14 +14436,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesInfoAsync(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12223,13 +14455,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 		///</summary>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesInfoForAll<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesInfoForAll<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12238,13 +14473,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 		///</summary>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesInfoForAllAsync<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12254,14 +14492,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 		///</summary>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesInfoForAll(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12271,14 +14512,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-info.html</para>	
 		///</summary>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesInfoForAllAsync(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12288,13 +14532,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesInfo<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12304,13 +14551,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesInfoAsync<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12321,14 +14571,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesInfo(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12339,14 +14592,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">A comma-separated list of metrics you wish returned. Leave empty to return all.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesInfoAsync(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node_id, string metric, Func<NodesInfoRequestParameters, NodesInfoRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_shutdown
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12354,13 +14610,16 @@ public interface IElasticsearchClient
 		///<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/cluster-nodes-shutdown.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesShutdownForAll<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesShutdownForAll<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_shutdown
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12368,13 +14627,16 @@ public interface IElasticsearchClient
 		///<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/cluster-nodes-shutdown.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesShutdownForAllAsync<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesShutdownForAllAsync<T>(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_shutdown
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12383,14 +14645,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-nodes-shutdown.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesShutdownForAll(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesShutdownForAll(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_shutdown
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12399,14 +14664,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-nodes-shutdown.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesShutdownForAllAsync(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownForAllAsync(Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cluster/nodes/{node_id}/_shutdown
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12415,13 +14683,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you&#39;re connected to, leave empty to perform the operation on all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesShutdown<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesShutdown<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cluster/nodes/{node_id}/_shutdown
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12430,13 +14701,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you&#39;re connected to, leave empty to perform the operation on all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesShutdownAsync<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesShutdownAsync<T>(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cluster/nodes/{node_id}/_shutdown
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12446,14 +14720,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you&#39;re connected to, leave empty to perform the operation on all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesShutdown(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesShutdown(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_cluster/nodes/{node_id}/_shutdown
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12463,14 +14740,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-shutdown.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to perform the operation on; use `_local` to perform the operation on the node you&#39;re connected to, leave empty to perform the operation on all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesShutdownAsync(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownAsync(string node_id, Func<NodesShutdownRequestParameters, NodesShutdownRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12478,13 +14758,16 @@ public interface IElasticsearchClient
 		///<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/cluster-nodes-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesStatsForAll<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStatsForAll<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12492,13 +14775,16 @@ public interface IElasticsearchClient
 		///<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/cluster-nodes-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesStatsForAllAsync<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12507,14 +14793,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStatsForAll(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12523,14 +14812,17 @@ public interface IElasticsearchClient
 		///<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/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsForAllAsync(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12539,13 +14831,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesStats<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStats<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12554,13 +14849,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesStatsAsync<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12570,14 +14868,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStats(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12587,14 +14888,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsAsync(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12603,13 +14907,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesStatsForAll<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12618,13 +14925,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesStatsForAllAsync<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12634,14 +14944,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStatsForAll(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12651,14 +14964,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/cluster-nodes-stats.html</para>	
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsForAllAsync(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12668,13 +14984,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesStats<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12684,13 +15003,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesStatsAsync<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12701,14 +15023,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStats(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12719,14 +15044,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsAsync(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}/{index_metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12736,13 +15064,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesStatsForAll<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}/{index_metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12752,13 +15083,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesStatsForAllAsync<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}/{index_metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12769,14 +15103,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStatsForAll(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/stats/{metric}/{index_metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12787,14 +15124,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsForAllAsync(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12805,13 +15145,16 @@ public interface IElasticsearchClient
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> NodesStats<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12822,13 +15165,16 @@ public interface IElasticsearchClient
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> NodesStatsAsync<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12840,14 +15186,17 @@ public interface IElasticsearchClient
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> NodesStats(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_nodes/{node_id}/stats/{metric}/{index_metric}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12859,14 +15208,17 @@ public interface IElasticsearchClient
 		///<param name="node_id">A comma-separated list of node IDs or names to limit the returned information; use `_local` to return information from the node you&#39;re connecting to, leave empty to get information from all nodes</param>
 		///<param name="metric">Limit the information returned to the specified metrics</param>
 		///<param name="index_metric">Limit the information returned for `indices` metric to the specific index metrics. Isn&#39;t used if `indices` (or `all`) metric isn&#39;t specified.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> NodesStatsAsync(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string node_id, string metric, string index_metric, Func<NodesStatsRequestParameters, NodesStatsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12876,13 +15228,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> PercolateGet<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> PercolateGet<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12892,13 +15247,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> PercolateGetAsync<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12909,14 +15267,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> PercolateGet(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_percolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12927,14 +15288,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PercolateGetAsync(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12945,13 +15309,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> PercolateGet<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> PercolateGet<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -12962,13 +15329,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> PercolateGetAsync<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -12980,14 +15350,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> PercolateGet(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -12999,14 +15372,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PercolateGetAsync(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string index, string type, string id, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13017,13 +15393,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Percolate<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Percolate<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13034,13 +15413,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> PercolateAsync<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13052,14 +15434,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Percolate(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_percolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13071,14 +15456,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index of the document being percolated.</param>
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PercolateAsync(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13090,13 +15478,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Percolate<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Percolate<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13108,13 +15499,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> PercolateAsync<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13127,14 +15521,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Percolate(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Percolate(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_percolate
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13147,14 +15544,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document being percolated.</param>
 		///<param name="id">Substitute the document in the request body with a document that is known by the specified id. On top of the id, the index and type parameter will be used to retrieve the document from within the cluster.</param>
 		///<param name="body">The percolator request definition using the percolate DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PercolateAsync(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string index, string type, string id, object body, Func<PercolateRequestParameters, PercolateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13162,13 +15562,16 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///<para>See also: http://www.elasticsearch.org/guide/</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Ping<T>(Func<PingRequestParameters, PingRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Ping<T>(Func<PingRequestParameters, PingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13176,13 +15579,16 @@ public interface IElasticsearchClient
 		///<para> - If T is of type VoidResponse the response stream will be ignored completely</para>
 		///<para>See also: http://www.elasticsearch.org/guide/</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> PingAsync<T>(Func<PingRequestParameters, PingRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> PingAsync<T>(Func<PingRequestParameters, PingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13191,14 +15597,17 @@ public interface IElasticsearchClient
 		///<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/</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Ping(Func<PingRequestParameters, PingRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Ping(Func<PingRequestParameters, PingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a HEAD on /
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13207,14 +15616,17 @@ public interface IElasticsearchClient
 		///<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/</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> PingAsync(Func<PingRequestParameters, PingRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingRequestParameters, PingRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13222,13 +15634,16 @@ public interface IElasticsearchClient
 		///<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/search-request-scroll.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ScrollGet<T>(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ScrollGet<T>(Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13236,13 +15651,16 @@ public interface IElasticsearchClient
 		///<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/search-request-scroll.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ScrollGetAsync<T>(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13251,14 +15669,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-request-scroll.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ScrollGet(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ScrollGet(Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search/scroll
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13267,14 +15688,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-request-scroll.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ScrollGetAsync(Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13283,13 +15707,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="scroll_id">The scroll ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> ScrollGet<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> ScrollGet<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search/scroll/{scroll_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13298,13 +15725,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="scroll_id">The scroll ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ScrollGetAsync<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13314,14 +15744,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="scroll_id">The scroll ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> ScrollGet(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> ScrollGet(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search/scroll/{scroll_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13331,14 +15764,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="scroll_id">The scroll ID</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ScrollGetAsync(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(string scroll_id, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13347,13 +15783,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Scroll<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Scroll<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search/scroll
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13362,13 +15801,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ScrollAsync<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ScrollAsync<T>(object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search/scroll
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13378,14 +15820,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Scroll(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Scroll(object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search/scroll
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13395,14 +15840,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-request-scroll.html</para>	
 		///</summary>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ScrollAsync(object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13412,13 +15860,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="scroll_id">The scroll ID</param>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Scroll<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Scroll<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search/scroll/{scroll_id}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13428,13 +15879,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="scroll_id">The scroll ID</param>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> ScrollAsync<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> ScrollAsync<T>(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13445,14 +15899,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="scroll_id">The scroll ID</param>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Scroll(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Scroll(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search/scroll/{scroll_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13463,14 +15920,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="scroll_id">The scroll ID</param>
 		///<param name="body">The scroll ID if not passed by URL or query parameter.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> ScrollAsync(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(string scroll_id, object body, Func<ScrollRequestParameters, ScrollRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13478,13 +15938,16 @@ public interface IElasticsearchClient
 		///<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/search-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SearchGet<T>(Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SearchGet<T>(Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13492,13 +15955,16 @@ public interface IElasticsearchClient
 		///<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/search-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SearchGetAsync<T>(Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchGetAsync<T>(Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13507,14 +15973,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SearchGet(Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SearchGet(Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13523,14 +15992,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchGetAsync(Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13539,13 +16011,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SearchGet<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SearchGet<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13554,13 +16029,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SearchGetAsync<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13570,14 +16048,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SearchGet(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SearchGet(string index, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13587,14 +16068,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchGetAsync(string index, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13604,13 +16088,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SearchGet<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SearchGet<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13620,13 +16107,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SearchGetAsync<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13637,14 +16127,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SearchGet(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SearchGet(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13655,14 +16148,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchGetAsync(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string index, string type, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13671,13 +16167,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Search<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Search<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13686,13 +16185,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SearchAsync<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchAsync<T>(object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13702,14 +16204,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Search(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Search(object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13719,14 +16224,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchAsync(object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13736,13 +16244,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Search<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Search<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13752,13 +16263,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SearchAsync<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13769,14 +16283,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Search(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Search(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13787,14 +16304,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchAsync(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13805,13 +16325,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Search<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Search<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_search
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13822,13 +16345,16 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SearchAsync<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_search
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13840,14 +16366,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Search(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Search(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/_search
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13859,14 +16388,17 @@ public interface IElasticsearchClient
 		///<param name="index">A comma-separated list of index names to search; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="type">A comma-separated list of document types to search; leave empty to perform the operation on all types</param>
 		///<param name="body">The search definition using the Query DSL</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SearchAsync(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index, string type, object body, Func<SearchRequestParameters, SearchRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13877,13 +16409,16 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotCreate<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotCreate<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13894,13 +16429,16 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotCreateAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotCreateAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13912,14 +16450,17 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotCreate(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotCreate(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -13931,14 +16472,17 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotCreateAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13949,13 +16493,16 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotCreatePost<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotCreatePost<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -13966,13 +16513,16 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotCreatePostAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotCreatePostAsync<T>(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -13984,14 +16534,17 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotCreatePost(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotCreatePost(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14003,14 +16556,17 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">The snapshot definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotCreatePostAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreatePostAsync(string repository, string snapshot, object body, Func<SnapshotCreateRequestParameters, SnapshotCreateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14020,13 +16576,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotCreateRepository<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotCreateRepository<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14036,13 +16595,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotCreateRepositoryAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14053,14 +16615,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotCreateRepository(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepository(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a PUT on /_snapshot/{repository}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14071,14 +16636,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotCreateRepositoryAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14088,13 +16656,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotCreateRepositoryPost<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotCreateRepositoryPost<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14104,13 +16675,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotCreateRepositoryPostAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryPostAsync<T>(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14121,14 +16695,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotCreateRepositoryPost(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepositoryPost(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14139,14 +16716,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="body">The repository definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotCreateRepositoryPostAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryPostAsync(string repository, object body, Func<SnapshotCreateRepositoryRequestParameters, SnapshotCreateRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14156,13 +16736,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotDelete<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotDelete<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14172,13 +16755,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotDeleteAsync<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotDeleteAsync<T>(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14189,14 +16775,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotDelete(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotDelete(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14207,14 +16796,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotDeleteAsync(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteAsync(string repository, string snapshot, Func<SnapshotDeleteRequestParameters, SnapshotDeleteRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14223,13 +16815,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 		///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotDeleteRepository<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotDeleteRepository<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14238,13 +16833,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 		///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotDeleteRepositoryAsync<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryAsync<T>(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14254,14 +16852,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 		///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotDeleteRepository(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotDeleteRepository(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_snapshot/{repository}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14271,14 +16872,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 		///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotDeleteRepositoryAsync(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteRepositoryAsync(string repository, Func<SnapshotDeleteRepositoryRequestParameters, SnapshotDeleteRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14288,13 +16892,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A comma-separated list of snapshot names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotGet<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotGet<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14304,13 +16911,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A comma-separated list of snapshot names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotGetAsync<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotGetAsync<T>(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14321,14 +16931,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A comma-separated list of snapshot names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotGet(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotGet(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}/{snapshot}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14339,14 +16952,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A comma-separated list of snapshot names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotGetAsync(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetAsync(string repository, string snapshot, Func<SnapshotGetRequestParameters, SnapshotGetRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14354,13 +16970,16 @@ public interface IElasticsearchClient
 		///<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/modules-snapshots.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotGetRepository<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotGetRepository<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14368,13 +16987,16 @@ public interface IElasticsearchClient
 		///<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/modules-snapshots.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotGetRepositoryAsync<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14383,14 +17005,17 @@ public interface IElasticsearchClient
 		///<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/1.x/modules-snapshots.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotGetRepository(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14399,14 +17024,17 @@ public interface IElasticsearchClient
 		///<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/1.x/modules-snapshots.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotGetRepositoryAsync(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14415,13 +17043,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 		///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotGetRepository<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotGetRepository<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14430,13 +17061,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 		///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotGetRepositoryAsync<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14446,14 +17080,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 		///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotGetRepository(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_snapshot/{repository}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14463,14 +17100,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/modules-snapshots.html</para>	
 		///</summary>
 		///<param name="repository">A comma-separated list of repository names</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotGetRepositoryAsync(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync(string repository, Func<SnapshotGetRepositoryRequestParameters, SnapshotGetRepositoryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}/_restore
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14481,13 +17121,16 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">Details of what to restore</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SnapshotRestore<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SnapshotRestore<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}/_restore
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14498,13 +17141,16 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">Details of what to restore</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SnapshotRestoreAsync<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SnapshotRestoreAsync<T>(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}/_restore
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14516,14 +17162,17 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">Details of what to restore</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SnapshotRestore(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SnapshotRestore(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_snapshot/{repository}/{snapshot}/_restore
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14535,14 +17184,17 @@ public interface IElasticsearchClient
 		///<param name="repository">A repository name</param>
 		///<param name="snapshot">A snapshot name</param>
 		///<param name="body">Details of what to restore</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SnapshotRestoreAsync(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SnapshotRestoreAsync(string repository, string snapshot, object body, Func<SnapshotRestoreRequestParameters, SnapshotRestoreRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14551,13 +17203,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Suggest<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Suggest<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_suggest
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14566,13 +17221,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SuggestAsync<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SuggestAsync<T>(object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14582,14 +17240,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Suggest(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Suggest(object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /_suggest
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14599,14 +17260,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SuggestAsync(object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14616,13 +17280,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Suggest<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Suggest<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_suggest
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14632,13 +17299,16 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SuggestAsync<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SuggestAsync<T>(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14649,14 +17319,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Suggest(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Suggest(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/_suggest
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14667,14 +17340,17 @@ public interface IElasticsearchClient
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
 		///<param name="body">The request definition</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SuggestAsync(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(string index, object body, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14682,13 +17358,16 @@ public interface IElasticsearchClient
 		///<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/search-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SuggestGet<T>(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SuggestGet<T>(Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_suggest
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14696,13 +17375,16 @@ public interface IElasticsearchClient
 		///<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/search-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SuggestGetAsync<T>(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14711,14 +17393,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SuggestGet(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SuggestGet(Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_suggest
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14727,14 +17412,17 @@ public interface IElasticsearchClient
 		///<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/1.x/search-search.html</para>	
 		///</summary>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SuggestGetAsync(Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14743,13 +17431,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> SuggestGet<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> SuggestGet<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_suggest
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14758,13 +17449,16 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> SuggestGetAsync<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(string index, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_suggest
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14774,14 +17468,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> SuggestGet(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> SuggestGet(string index, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/_suggest
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14791,14 +17488,17 @@ public interface IElasticsearchClient
 		///<para>See also: http://www.elasticsearch.org/guide/en/elasticsearch/reference/1.x/search-search.html</para>	
 		///</summary>
 		///<param name="index">A comma-separated list of index names to restrict the operation; use `_all` or empty string to perform the operation on all indices</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> SuggestGetAsync(string index, Func<SuggestRequestParameters, SuggestRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(string index, Func<SuggestRequestParameters, SuggestRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14809,13 +17509,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> TermvectorGet<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14826,13 +17529,16 @@ public interface IElasticsearchClient
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> TermvectorGetAsync<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> TermvectorGetAsync<T>(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14844,14 +17550,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> TermvectorGet(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14863,14 +17572,17 @@ public interface IElasticsearchClient
 		///<param name="index">The index in which the document resides.</param>
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> TermvectorGetAsync(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> TermvectorGetAsync(string index, string type, string id, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14882,13 +17594,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
 		///<param name="body">Define parameters. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Termvector<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Termvector<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14900,13 +17615,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
 		///<param name="body">Define parameters. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> TermvectorAsync<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> TermvectorAsync<T>(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14919,14 +17637,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
 		///<param name="body">Define parameters. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Termvector(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Termvector(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_termvector
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -14939,14 +17660,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document.</param>
 		///<param name="id">The id of the document.</param>
 		///<param name="body">Define parameters. See documentation.</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> TermvectorAsync(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string index, string type, string id, object body, Func<TermvectorRequestParameters, TermvectorRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_update
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14958,13 +17682,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The request definition using either `script` or partial `doc`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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> Update<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null, object deserializationState = null);
+		ElasticsearchResponse<T> Update<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_update
 		///<para></para>Returns: A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -14976,13 +17703,16 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The request definition using either `script` or partial `doc`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</param>
-///<param name="deserializationState">Optional state that will be passed to the deserialization call for the response</param>		///<returns>A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
+		///<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>> UpdateAsync<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null, object deserializationState = null);
+		Task<ElasticsearchResponse<T>> UpdateAsync<T>(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_update
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary
@@ -14995,14 +17725,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The request definition using either `script` or partial `doc`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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> Update(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null);
+		ElasticsearchResponse<DynamicDictionary> Update(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a POST on /{index}/{type}/{id}/_update
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -15015,14 +17748,17 @@ public interface IElasticsearchClient
 		///<param name="type">The type of the document</param>
 		///<param name="id">Document ID</param>
 		///<param name="body">The request definition using either `script` or partial `doc`</param>
-		///<param name="queryString">Optional function to specify any additional querystring parameters for the request.</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>> UpdateAsync(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> queryString = null);
+		Task<ElasticsearchResponse<DynamicDictionary>> UpdateAsync(string index, string type, string id, object body, Func<UpdateRequestParameters, UpdateRequestParameters> requestParameters = null);
 		
 	}
 }
\ No newline at end of file
diff --git a/src/Nest/DSL/AliasDescriptor.cs b/src/Nest/DSL/AliasDescriptor.cs
index 60331619371..4a9e8be0d12 100644
--- a/src/Nest/DSL/AliasDescriptor.cs
+++ b/src/Nest/DSL/AliasDescriptor.cs
@@ -44,7 +44,7 @@ public AliasDescriptor Remove(Func<AliasRemoveDescriptor, AliasRemoveDescriptor>
 		ElasticsearchPathInfo<AliasRequestParameters> IPathInfo<AliasRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
 			var pathInfo = new ElasticsearchPathInfo<AliasRequestParameters>();
-			pathInfo.QueryString = this._QueryString;
+			pathInfo.RequestParameters = this._QueryString;
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/CreateIndexDescriptor.cs b/src/Nest/DSL/CreateIndexDescriptor.cs
index d1ed8be995f..06737de8aec 100644
--- a/src/Nest/DSL/CreateIndexDescriptor.cs
+++ b/src/Nest/DSL/CreateIndexDescriptor.cs
@@ -155,7 +155,7 @@ ElasticsearchPathInfo<CreateIndexRequestParameters> IPathInfo<CreateIndexRequest
 			var pathInfo = new ElasticsearchPathInfo<CreateIndexRequestParameters>();
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			pathInfo.Index = this._Index;
-			pathInfo.QueryString = this._QueryString;
+			pathInfo.RequestParameters = this._QueryString;
 			return pathInfo;
 
 		}
diff --git a/src/Nest/DSL/InfoDescriptor.cs b/src/Nest/DSL/InfoDescriptor.cs
index fd24f7b5278..0fe92fbbe56 100644
--- a/src/Nest/DSL/InfoDescriptor.cs
+++ b/src/Nest/DSL/InfoDescriptor.cs
@@ -19,7 +19,7 @@ ElasticsearchPathInfo<InfoRequestParameters> IPathInfo<InfoRequestParameters>.To
 		{
 			var pathInfo = new ElasticsearchPathInfo<InfoRequestParameters>();
 			pathInfo.HttpMethod = PathInfoHttpMethod.GET;
-			pathInfo.QueryString = this._QueryString;
+			pathInfo.RequestParameters = this._QueryString;
 
 			return pathInfo;
 		}
diff --git a/src/Nest/DSL/Paths/DocumentPathDescriptor.cs b/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
index 812cf90fbcd..b78bec29f0c 100644
--- a/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
@@ -89,7 +89,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Type = type,
 				Id = id
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs b/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
index a07c2ee64a0..0b3e57122f9 100644
--- a/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
@@ -66,7 +66,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 				Type = type
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs b/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
index 106eb5e7b9d..9315dcc9cf5 100644
--- a/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
@@ -61,7 +61,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 				Name = this._Name
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs b/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
index 8be6a20ed6a..8b21dff8bae 100644
--- a/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
@@ -65,7 +65,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 			{
 				Index = index,
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexPathDescriptor.cs b/src/Nest/DSL/Paths/IndexPathDescriptor.cs
index 7f26ae17c91..1aeb5ccba73 100644
--- a/src/Nest/DSL/Paths/IndexPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexPathDescriptor.cs
@@ -53,7 +53,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 			{
 				Index = index,
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs b/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
index e8b71f79414..c64434b9080 100644
--- a/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
@@ -78,7 +78,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 				Type = type
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs b/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
index 0dec18d8196..02d1fffb630 100644
--- a/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
@@ -78,7 +78,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 				Type = type
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
index e128d2d2d3e..5104607b4d3 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
@@ -70,7 +70,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 			{
 				Index = index,
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
index eceb5520cea..9296b7e3612 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
@@ -55,7 +55,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 			{
 				Index = index,
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
index 8b68bfcfff0..733519f3874 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
@@ -139,7 +139,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Type = types,
 				Name = this._Name
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs b/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
index 87fb3ef31bf..5baa2ace0bb 100644
--- a/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
@@ -89,7 +89,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 				Type = type
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/NamePathDescriptor.cs b/src/Nest/DSL/Paths/NamePathDescriptor.cs
index 8fb92f875ee..307f552c9bf 100644
--- a/src/Nest/DSL/Paths/NamePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/NamePathDescriptor.cs
@@ -43,7 +43,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 			{
 				Name = this._Name
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs b/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
index b9846dcde30..1b451ba0eef 100644
--- a/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
+++ b/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
@@ -40,7 +40,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 			{
 				NodeId = this._NodeId
 			};
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/QueryPathDescriptor.cs b/src/Nest/DSL/Paths/QueryPathDescriptor.cs
index d2ccc9dbcd0..d09f62b6dfd 100644
--- a/src/Nest/DSL/Paths/QueryPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/QueryPathDescriptor.cs
@@ -138,7 +138,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 
 
 
-			pathInfo.QueryString = queryString ?? new K();
+			pathInfo.RequestParameters = queryString ?? new K();
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/ScrollDescriptor.cs b/src/Nest/DSL/ScrollDescriptor.cs
index 22cc7d057c3..d4d5d01a56f 100644
--- a/src/Nest/DSL/ScrollDescriptor.cs
+++ b/src/Nest/DSL/ScrollDescriptor.cs
@@ -26,7 +26,7 @@ ElasticsearchPathInfo<ScrollRequestParameters> IPathInfo<ScrollRequestParameters
 			pathInfo.ScrollId = this._QueryString._scroll_id;
 			// force scroll id out of RequestParameters (potentially very large)
 			this._QueryString._QueryStringDictionary.Remove("scroll_id");
-			pathInfo.QueryString = this._QueryString;
+			pathInfo.RequestParameters = this._QueryString;
 			return pathInfo;
 		}
 	}
diff --git a/src/Nest/DSL/SearchDescriptor.cs b/src/Nest/DSL/SearchDescriptor.cs
index e7f3d59cea5..5391fcf4218 100644
--- a/src/Nest/DSL/SearchDescriptor.cs
+++ b/src/Nest/DSL/SearchDescriptor.cs
@@ -1064,7 +1064,7 @@ ElasticsearchPathInfo<SearchRequestParameters> IPathInfo<SearchRequestParameters
 				? PathInfoHttpMethod.GET
 				: PathInfoHttpMethod.POST;
 
-			pathInfo.QueryString = this._QueryString;
+			pathInfo.RequestParameters = this._QueryString;
 
 			var inferrer = new ElasticInferrer(settings);
 			string indices;
diff --git a/src/Nest/DSL/UpdateDescriptor.cs b/src/Nest/DSL/UpdateDescriptor.cs
index 328308fcb94..70f347db05c 100644
--- a/src/Nest/DSL/UpdateDescriptor.cs
+++ b/src/Nest/DSL/UpdateDescriptor.cs
@@ -83,7 +83,7 @@ public UpdateDescriptor<T, K> DocAsUpsert(bool docAsUpsert = true)
 		ElasticsearchPathInfo<UpdateRequestParameters> IPathInfo<UpdateRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
 			var pathInfo = base.ToPathInfo<UpdateRequestParameters>(settings, this._QueryString);
-			pathInfo.QueryString = this._QueryString;
+			pathInfo.RequestParameters = this._QueryString;
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			
 			return pathInfo;
diff --git a/src/Nest/DSL/UpdateSettingsDescriptor.cs b/src/Nest/DSL/UpdateSettingsDescriptor.cs
index 656522088f2..8ee59d505af 100644
--- a/src/Nest/DSL/UpdateSettingsDescriptor.cs
+++ b/src/Nest/DSL/UpdateSettingsDescriptor.cs
@@ -399,7 +399,7 @@ public UpdateSettingsDescriptor Analysis(Func<AnalysisDescriptor, AnalysisDescri
 		ElasticsearchPathInfo<UpdateSettingsRequestParameters> IPathInfo<UpdateSettingsRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
 			var pathInfo = base.ToPathInfo<UpdateSettingsRequestParameters>(settings, this._QueryString);
-			pathInfo.QueryString = this._QueryString;
+			pathInfo.RequestParameters = this._QueryString;
 			pathInfo.HttpMethod = PathInfoHttpMethod.PUT;
 
 			return pathInfo;
diff --git a/src/Nest/DSL/ValidateQueryDescriptor.cs b/src/Nest/DSL/ValidateQueryDescriptor.cs
index 709bdb33e6c..35c95ca569c 100644
--- a/src/Nest/DSL/ValidateQueryDescriptor.cs
+++ b/src/Nest/DSL/ValidateQueryDescriptor.cs
@@ -23,7 +23,7 @@ public ValidateQueryDescriptor<T> Query(Func<QueryDescriptor<T>, BaseQuery> quer
 		ElasticsearchPathInfo<ValidateQueryRequestParameters> IPathInfo<ValidateQueryRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
 			var pathInfo = base.ToPathInfo<ValidateQueryRequestParameters>(settings, this._QueryString);
-			pathInfo.QueryString = this._QueryString;
+			pathInfo.RequestParameters = this._QueryString;
 			var qs = this._QueryString;
 			pathInfo.HttpMethod = (!qs._source.IsNullOrEmpty() || !qs._q.IsNullOrEmpty())
 				? PathInfoHttpMethod.GET
diff --git a/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs b/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs
index ff1bca821dc..eae3de19640 100644
--- a/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs
+++ b/src/Nest/Domain/Paths/ElasticSearchPathInfo.cs
@@ -8,7 +8,7 @@ namespace Nest
 		public string Index { get; set; }
 		public string Type { get; set; }
 		public string Id { get; set; }
-		public T QueryString { get; set; }
+		public T RequestParameters { get; set; }
 		public string Name { get; set; }
 		public string Field { get; set; }
 		public string ScrollId { get; set; }
@@ -24,7 +24,13 @@ namespace Nest
 
 		public ElasticsearchPathInfo()
 		{
-			this.QueryString = new T();
+			this.RequestParameters = new T();
+		}
+
+		public ElasticsearchPathInfo<T> DeserializationState(object deserializationState)
+		{
+			this.RequestParameters.DeserializationState(deserializationState);
+			return this;
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/Nest/ElasticClient-Aliases.cs b/src/Nest/ElasticClient-Aliases.cs
index aaecc207622..3f1d2581443 100644
--- a/src/Nest/ElasticClient-Aliases.cs
+++ b/src/Nest/ElasticClient-Aliases.cs
@@ -36,8 +36,7 @@ public IGetAliasesResponse GetAliases(Func<GetAliasesDescriptor, GetAliasesDescr
 			return this.Dispatch<GetAliasesDescriptor, GetAliasesRequestParameters, GetAliasesResponse>(
 				getAliasesDescriptor,
 				(p, d) => this.RawDispatch.IndicesGetAliasDispatch<GetAliasesResponse>(
-					p,
-					new GetAliasesConverter(DeserializeGetAliasesResponse)
+					p.DeserializationState(new GetAliasesConverter(DeserializeGetAliasesResponse))
 				)
 			);
 		}
@@ -48,8 +47,7 @@ public Task<IGetAliasesResponse> GetAliasesAsync(Func<GetAliasesDescriptor, GetA
 			return this.DispatchAsync<GetAliasesDescriptor, GetAliasesRequestParameters, GetAliasesResponse, IGetAliasesResponse>(
 				getAliasesDescriptor,
 				(p, d) => this.RawDispatch.IndicesGetAliasDispatchAsync<GetAliasesResponse>(
-					p,
-					new GetAliasesConverter(DeserializeGetAliasesResponse)
+					p.DeserializationState(new GetAliasesConverter(DeserializeGetAliasesResponse))
 				)
 			);
 		}
diff --git a/src/Nest/ElasticClient-IndexExists.cs b/src/Nest/ElasticClient-IndexExists.cs
index 31e1aeed1d2..49ce5719661 100644
--- a/src/Nest/ElasticClient-IndexExists.cs
+++ b/src/Nest/ElasticClient-IndexExists.cs
@@ -15,10 +15,10 @@ public IIndexExistsResponse IndexExists(Func<IndexExistsDescriptor, IndexExistsD
 			return this.Dispatch<IndexExistsDescriptor, IndexExistsRequestParameters, IndexExistsResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesExistsDispatch<IndexExistsResponse>(
-					p,
-					new IndexExistConverter(DeserializeExistsResponse)
-					), true
-				);
+					p.DeserializationState(new IndexExistConverter(DeserializeExistsResponse))
+				),
+				allow404: true
+			);
 		}
 
 		/// <inheritdoc />
@@ -27,10 +27,10 @@ public Task<IIndexExistsResponse> IndexExistsAsync(Func<IndexExistsDescriptor, I
 			return this.DispatchAsync<IndexExistsDescriptor, IndexExistsRequestParameters, IndexExistsResponse, IIndexExistsResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesExistsDispatchAsync<IndexExistsResponse>(
-					p,
-					new IndexExistConverter(DeserializeExistsResponse)
-					), true
-				);
+					p.DeserializationState(new IndexExistConverter(DeserializeExistsResponse))
+				), 
+				allow404: true
+			);
 		}
 
 		private IndexExistsResponse DeserializeExistsResponse(IElasticsearchResponse response, Stream stream)
diff --git a/src/Nest/ElasticClient-MappingGet.cs b/src/Nest/ElasticClient-MappingGet.cs
index ecd2a8c2018..3541b8ab795 100644
--- a/src/Nest/ElasticClient-MappingGet.cs
+++ b/src/Nest/ElasticClient-MappingGet.cs
@@ -17,8 +17,7 @@ public IGetMappingResponse GetMapping(Func<GetMappingDescriptor, GetMappingDescr
 			return this.Dispatch<GetMappingDescriptor, GetMappingRequestParameters, GetMappingResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesGetMappingDispatch<GetMappingResponse>(
-					p,
-					new GetMappingConverter((r, s) => DeserializeGetMappingResponse(r, d, s))
+					p.DeserializationState(new GetMappingConverter((r, s) => DeserializeGetMappingResponse(r, d, s)))
 				)
 			);
 		}
@@ -29,8 +28,7 @@ public Task<IGetMappingResponse> GetMappingAsync(Func<GetMappingDescriptor, GetM
 			return this.DispatchAsync<GetMappingDescriptor, GetMappingRequestParameters, GetMappingResponse, IGetMappingResponse>(
 				selector,
 				(p, d) => this.RawDispatch.IndicesGetMappingDispatchAsync<GetMappingResponse>(
-					p,
-					new GetMappingConverter((r, s) => DeserializeGetMappingResponse(r, d, s))
+					p.DeserializationState(new GetMappingConverter((r, s) => DeserializeGetMappingResponse(r, d, s)))
 				)
 			);
 		}
diff --git a/src/Nest/ElasticClient-MultiGet.cs b/src/Nest/ElasticClient-MultiGet.cs
index 18e313e7a9c..70d4b65f720 100644
--- a/src/Nest/ElasticClient-MultiGet.cs
+++ b/src/Nest/ElasticClient-MultiGet.cs
@@ -18,7 +18,7 @@ public IMultiGetResponse MultiGet(Func<MultiGetDescriptor, MultiGetDescriptor> m
 			var converter = CreateCovariantMultiGetConverter(descriptor);
 			return this.Dispatch<MultiGetDescriptor, MultiGetRequestParameters, MultiGetResponse>(
 				descriptor,
-				(p, d) => this.RawDispatch.MgetDispatch<MultiGetResponse>(p, d, converter)
+				(p, d) => this.RawDispatch.MgetDispatch<MultiGetResponse>(p.DeserializationState(converter), d)
 			);
 		}
 
@@ -30,7 +30,7 @@ public Task<IMultiGetResponse> MultiGetAsync(Func<MultiGetDescriptor, MultiGetDe
 			var converter = CreateCovariantMultiGetConverter(descriptor);
 			return this.DispatchAsync<MultiGetDescriptor, MultiGetRequestParameters, MultiGetResponse, IMultiGetResponse>(
 				descriptor,
-				(p, d) => this.RawDispatch.MgetDispatchAsync<MultiGetResponse>(p, d, converter)
+				(p, d) => this.RawDispatch.MgetDispatchAsync<MultiGetResponse>(p.DeserializationState(converter), d)
 			);
 		}
 
diff --git a/src/Nest/ElasticClient-MultiSearch.cs b/src/Nest/ElasticClient-MultiSearch.cs
index 7cce0837857..c3d5507dfc5 100644
--- a/src/Nest/ElasticClient-MultiSearch.cs
+++ b/src/Nest/ElasticClient-MultiSearch.cs
@@ -20,7 +20,7 @@ public IMultiSearchResponse MultiSearch(Func<MultiSearchDescriptor, MultiSearchD
 				{
 					string json = Serializer.SerializeMultiSearch(d);
 					JsonConverter converter = CreateMultiSearchConverter(d);
-					return this.RawDispatch.MsearchDispatch<MultiSearchResponse>(p, json, converter);
+					return this.RawDispatch.MsearchDispatch<MultiSearchResponse>(p.DeserializationState(converter), json);
 				}
 			);
 		}
@@ -35,7 +35,7 @@ public Task<IMultiSearchResponse> MultiSearchAsync(
 				{
 					string json = Serializer.SerializeMultiSearch(d);
 					JsonConverter converter = CreateMultiSearchConverter(d);
-					return this.RawDispatch.MsearchDispatchAsync<MultiSearchResponse>(p, json, converter);
+					return this.RawDispatch.MsearchDispatchAsync<MultiSearchResponse>(p.DeserializationState(converter), json);
 				}
 			);
 		}
diff --git a/src/Nest/ElasticClient-Search.cs b/src/Nest/ElasticClient-Search.cs
index 6ef1d7f4cde..3e95e909dd5 100644
--- a/src/Nest/ElasticClient-Search.cs
+++ b/src/Nest/ElasticClient-Search.cs
@@ -23,11 +23,12 @@ public IQueryResponse<TResult> Search<T, TResult>(Func<SearchDescriptor<T>, Sear
 		{
 			searchSelector.ThrowIfNull("searchSelector");
 			var descriptor = searchSelector(new SearchDescriptor<T>());
-			var pathInfo =
-				((IPathInfo<SearchRequestParameters>) descriptor).ToPathInfo(_connectionSettings);
 			var deserializationState = this.CreateCovariantSearchSelector<T, TResult>(descriptor);
-			var status = this.RawDispatch.SearchDispatch<QueryResponse<TResult>>(pathInfo,
-				descriptor, deserializationState);
+			var pathInfo =
+				((IPathInfo<SearchRequestParameters>) descriptor).ToPathInfo(_connectionSettings)
+				.DeserializationState(deserializationState);
+
+			var status = this.RawDispatch.SearchDispatch<QueryResponse<TResult>>(pathInfo, descriptor);
 			return status.Success ? status.Response : CreateInvalidInstance<QueryResponse<TResult>>(status);
 		}
 
@@ -47,10 +48,12 @@ public Task<IQueryResponse<TResult>> SearchAsync<T, TResult>(
 		{
 			searchSelector.ThrowIfNull("searchSelector");
 			var descriptor = searchSelector(new SearchDescriptor<T>());
-			var pathInfo =
-				((IPathInfo<SearchRequestParameters>) descriptor).ToPathInfo(_connectionSettings);
 			var deserializationState = this.CreateCovariantSearchSelector<T, TResult>(descriptor);
-			return this.RawDispatch.SearchDispatchAsync<QueryResponse<TResult>>(pathInfo, descriptor, deserializationState)
+			var pathInfo =
+				((IPathInfo<SearchRequestParameters>) descriptor).ToPathInfo(_connectionSettings)
+				.DeserializationState(deserializationState);
+
+			return this.RawDispatch.SearchDispatchAsync<QueryResponse<TResult>>(pathInfo, descriptor)
 				.ContinueWith<IQueryResponse<TResult>>(t => t.Result.Success
 					? t.Result.Response
 					: CreateInvalidInstance<QueryResponse<TResult>>(t.Result));
diff --git a/src/Nest/ElasticClient-Template.cs b/src/Nest/ElasticClient-Template.cs
index 05d2055ce08..0e53df36a0b 100644
--- a/src/Nest/ElasticClient-Template.cs
+++ b/src/Nest/ElasticClient-Template.cs
@@ -18,8 +18,9 @@ public ITemplateResponse GetTemplate(string name,
 			getTemplateSelector = getTemplateSelector ?? (s => s);
 			return this.Dispatch<GetTemplateDescriptor, GetTemplateRequestParameters, TemplateResponse>(
 				d => getTemplateSelector(d.Name(name)),
-				(p, d) =>
-					RawDispatch.IndicesGetTemplateDispatch<TemplateResponse>(p, (GetTemplateConverter) DeserializeTemplateResponse)
+				(p, d) => RawDispatch.IndicesGetTemplateDispatch<TemplateResponse>(
+					p.DeserializationState((GetTemplateConverter) DeserializeTemplateResponse)
+				)
 			);
 		}
 
@@ -31,7 +32,8 @@ public Task<ITemplateResponse> GetTemplateAsync(string name,
 			return this.DispatchAsync<GetTemplateDescriptor, GetTemplateRequestParameters, TemplateResponse, ITemplateResponse>(
 				d => getTemplateSelector(d.Name(name)),
 				(p, d) => this.RawDispatch.IndicesGetTemplateDispatchAsync<TemplateResponse>(
-					p, (GetTemplateConverter) DeserializeTemplateResponse)
+					p.DeserializationState((GetTemplateConverter) DeserializeTemplateResponse)
+				)
 			);
 		}
 
diff --git a/src/Nest/ElasticClient-Warmers.cs b/src/Nest/ElasticClient-Warmers.cs
index 1c4a413bd8a..75d72659c62 100644
--- a/src/Nest/ElasticClient-Warmers.cs
+++ b/src/Nest/ElasticClient-Warmers.cs
@@ -40,8 +40,7 @@ public IWarmerResponse GetWarmer(string name, Func<GetWarmerDescriptor, GetWarme
 			return this.Dispatch<GetWarmerDescriptor, GetWarmerRequestParameters, WarmerResponse>(
 				d => selector(d.Name(name).AllIndices()),
 				(p, d) => this.RawDispatch.IndicesGetWarmerDispatch<WarmerResponse>(
-					p,
-					new GetWarmerConverter(DeserializeWarmerResponse)
+					p.DeserializationState(new GetWarmerConverter(DeserializeWarmerResponse))
 				)
 			);
 		}
@@ -54,8 +53,7 @@ public Task<IWarmerResponse> GetWarmerAsync(string name,
 			return this.DispatchAsync<GetWarmerDescriptor, GetWarmerRequestParameters, WarmerResponse, IWarmerResponse>(
 				d => selector(d.Name(name).AllIndices()),
 				(p, d) => this.RawDispatch.IndicesGetWarmerDispatchAsync<WarmerResponse>(
-					p,
-					new GetWarmerConverter(DeserializeWarmerResponse)
+					p.DeserializationState(new GetWarmerConverter(DeserializeWarmerResponse))
 				)
 			);
 		}
diff --git a/src/Nest/RawDispatch.generated.cs b/src/Nest/RawDispatch.generated.cs
index 6490a7d539d..797de02242e 100644
--- a/src/Nest/RawDispatch.generated.cs
+++ b/src/Nest/RawDispatch.generated.cs
@@ -18,32 +18,32 @@ internal partial class RawDispatch
 	{
 	
 		
-		internal ElasticsearchResponse<T> BulkDispatch<T>(ElasticsearchPathInfo<BulkRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> BulkDispatch<T>(ElasticsearchPathInfo<BulkRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_bulk
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.Bulk<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Bulk<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_bulk
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.Bulk<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Bulk<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_bulk
 					if (body != null)
-						return this.Raw.Bulk<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Bulk<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/{type}/_bulk
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.BulkPut<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.BulkPut<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//PUT /{index}/_bulk
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.BulkPut<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.BulkPut<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//PUT /_bulk
 					if (body != null)
-						return this.Raw.BulkPut<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.BulkPut<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -51,32 +51,32 @@ internal ElasticsearchResponse<T> BulkDispatch<T>(ElasticsearchPathInfo<BulkRequ
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> BulkDispatchAsync<T>(ElasticsearchPathInfo<BulkRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> BulkDispatchAsync<T>(ElasticsearchPathInfo<BulkRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_bulk
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.BulkAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.BulkAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_bulk
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.BulkAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.BulkAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_bulk
 					if (body != null)
-						return this.Raw.BulkAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.BulkAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/{type}/_bulk
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.BulkPutAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.BulkPutAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//PUT /{index}/_bulk
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.BulkPutAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.BulkPutAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//PUT /_bulk
 					if (body != null)
-						return this.Raw.BulkPutAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.BulkPutAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -84,362 +84,362 @@ internal Task<ElasticsearchResponse<T>> BulkDispatchAsync<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatAliasesDispatch<T>(ElasticsearchPathInfo<CatAliasesRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatAliasesDispatch<T>(ElasticsearchPathInfo<CatAliasesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/aliases/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.CatAliases<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatAliases<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_cat/aliases
-					return this.Raw.CatAliases<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatAliases<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatAliases() into any of the following paths: \r\n - /_cat/aliases\r\n - /_cat/aliases/{name}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatAliasesDispatchAsync<T>(ElasticsearchPathInfo<CatAliasesRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatAliasesDispatchAsync<T>(ElasticsearchPathInfo<CatAliasesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/aliases/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.CatAliasesAsync<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatAliasesAsync<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_cat/aliases
-					return this.Raw.CatAliasesAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatAliasesAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatAliases() into any of the following paths: \r\n - /_cat/aliases\r\n - /_cat/aliases/{name}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatAllocationDispatch<T>(ElasticsearchPathInfo<CatAllocationRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatAllocationDispatch<T>(ElasticsearchPathInfo<CatAllocationRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/allocation/{node_id}
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.CatAllocation<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatAllocation<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_cat/allocation
-					return this.Raw.CatAllocation<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatAllocation<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatAllocation() into any of the following paths: \r\n - /_cat/allocation\r\n - /_cat/allocation/{node_id}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatAllocationDispatchAsync<T>(ElasticsearchPathInfo<CatAllocationRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatAllocationDispatchAsync<T>(ElasticsearchPathInfo<CatAllocationRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/allocation/{node_id}
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.CatAllocationAsync<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatAllocationAsync<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_cat/allocation
-					return this.Raw.CatAllocationAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatAllocationAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatAllocation() into any of the following paths: \r\n - /_cat/allocation\r\n - /_cat/allocation/{node_id}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatCountDispatch<T>(ElasticsearchPathInfo<CatCountRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatCountDispatch<T>(ElasticsearchPathInfo<CatCountRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/count/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CatCount<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatCount<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cat/count
-					return this.Raw.CatCount<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatCount<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatCount() into any of the following paths: \r\n - /_cat/count\r\n - /_cat/count/{index}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatCountDispatchAsync<T>(ElasticsearchPathInfo<CatCountRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatCountDispatchAsync<T>(ElasticsearchPathInfo<CatCountRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/count/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CatCountAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatCountAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cat/count
-					return this.Raw.CatCountAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatCountAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatCount() into any of the following paths: \r\n - /_cat/count\r\n - /_cat/count/{index}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatHealthDispatch<T>(ElasticsearchPathInfo<CatHealthRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatHealthDispatch<T>(ElasticsearchPathInfo<CatHealthRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/health
-					return this.Raw.CatHealth<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatHealth<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatHealth() into any of the following paths: \r\n - /_cat/health");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatHealthDispatchAsync<T>(ElasticsearchPathInfo<CatHealthRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatHealthDispatchAsync<T>(ElasticsearchPathInfo<CatHealthRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/health
-					return this.Raw.CatHealthAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatHealthAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatHealth() into any of the following paths: \r\n - /_cat/health");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatHelpDispatch<T>(ElasticsearchPathInfo<CatHelpRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatHelpDispatch<T>(ElasticsearchPathInfo<CatHelpRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat
-					return this.Raw.CatHelp<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatHelp<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatHelp() into any of the following paths: \r\n - /_cat");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatHelpDispatchAsync<T>(ElasticsearchPathInfo<CatHelpRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatHelpDispatchAsync<T>(ElasticsearchPathInfo<CatHelpRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat
-					return this.Raw.CatHelpAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatHelpAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatHelp() into any of the following paths: \r\n - /_cat");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatIndicesDispatch<T>(ElasticsearchPathInfo<CatIndicesRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatIndicesDispatch<T>(ElasticsearchPathInfo<CatIndicesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/indices/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CatIndices<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatIndices<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cat/indices
-					return this.Raw.CatIndices<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatIndices<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatIndices() into any of the following paths: \r\n - /_cat/indices\r\n - /_cat/indices/{index}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatIndicesDispatchAsync<T>(ElasticsearchPathInfo<CatIndicesRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatIndicesDispatchAsync<T>(ElasticsearchPathInfo<CatIndicesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/indices/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CatIndicesAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatIndicesAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cat/indices
-					return this.Raw.CatIndicesAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatIndicesAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatIndices() into any of the following paths: \r\n - /_cat/indices\r\n - /_cat/indices/{index}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatMasterDispatch<T>(ElasticsearchPathInfo<CatMasterRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatMasterDispatch<T>(ElasticsearchPathInfo<CatMasterRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/master
-					return this.Raw.CatMaster<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatMaster<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatMaster() into any of the following paths: \r\n - /_cat/master");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatMasterDispatchAsync<T>(ElasticsearchPathInfo<CatMasterRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatMasterDispatchAsync<T>(ElasticsearchPathInfo<CatMasterRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/master
-					return this.Raw.CatMasterAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatMasterAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatMaster() into any of the following paths: \r\n - /_cat/master");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatNodesDispatch<T>(ElasticsearchPathInfo<CatNodesRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatNodesDispatch<T>(ElasticsearchPathInfo<CatNodesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/nodes
-					return this.Raw.CatNodes<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatNodes<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatNodes() into any of the following paths: \r\n - /_cat/nodes");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatNodesDispatchAsync<T>(ElasticsearchPathInfo<CatNodesRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatNodesDispatchAsync<T>(ElasticsearchPathInfo<CatNodesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/nodes
-					return this.Raw.CatNodesAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatNodesAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatNodes() into any of the following paths: \r\n - /_cat/nodes");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatPendingTasksDispatch<T>(ElasticsearchPathInfo<CatPendingTasksRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatPendingTasksDispatch<T>(ElasticsearchPathInfo<CatPendingTasksRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/pending_tasks
-					return this.Raw.CatPendingTasks<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatPendingTasks<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatPendingTasks() into any of the following paths: \r\n - /_cat/pending_tasks");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatPendingTasksDispatchAsync<T>(ElasticsearchPathInfo<CatPendingTasksRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatPendingTasksDispatchAsync<T>(ElasticsearchPathInfo<CatPendingTasksRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/pending_tasks
-					return this.Raw.CatPendingTasksAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatPendingTasksAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatPendingTasks() into any of the following paths: \r\n - /_cat/pending_tasks");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatRecoveryDispatch<T>(ElasticsearchPathInfo<CatRecoveryRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatRecoveryDispatch<T>(ElasticsearchPathInfo<CatRecoveryRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/recovery/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CatRecovery<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatRecovery<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cat/recovery
-					return this.Raw.CatRecovery<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatRecovery<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatRecovery() into any of the following paths: \r\n - /_cat/recovery\r\n - /_cat/recovery/{index}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatRecoveryDispatchAsync<T>(ElasticsearchPathInfo<CatRecoveryRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatRecoveryDispatchAsync<T>(ElasticsearchPathInfo<CatRecoveryRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/recovery/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CatRecoveryAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatRecoveryAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cat/recovery
-					return this.Raw.CatRecoveryAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatRecoveryAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatRecovery() into any of the following paths: \r\n - /_cat/recovery\r\n - /_cat/recovery/{index}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatShardsDispatch<T>(ElasticsearchPathInfo<CatShardsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatShardsDispatch<T>(ElasticsearchPathInfo<CatShardsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/shards/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CatShards<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatShards<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cat/shards
-					return this.Raw.CatShards<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatShards<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatShards() into any of the following paths: \r\n - /_cat/shards\r\n - /_cat/shards/{index}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatShardsDispatchAsync<T>(ElasticsearchPathInfo<CatShardsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatShardsDispatchAsync<T>(ElasticsearchPathInfo<CatShardsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/shards/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CatShardsAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CatShardsAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cat/shards
-					return this.Raw.CatShardsAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatShardsAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatShards() into any of the following paths: \r\n - /_cat/shards\r\n - /_cat/shards/{index}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CatThreadPoolDispatch<T>(ElasticsearchPathInfo<CatThreadPoolRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> CatThreadPoolDispatch<T>(ElasticsearchPathInfo<CatThreadPoolRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/thread_pool
-					return this.Raw.CatThreadPool<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatThreadPool<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatThreadPool() into any of the following paths: \r\n - /_cat/thread_pool");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CatThreadPoolDispatchAsync<T>(ElasticsearchPathInfo<CatThreadPoolRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CatThreadPoolDispatchAsync<T>(ElasticsearchPathInfo<CatThreadPoolRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cat/thread_pool
-					return this.Raw.CatThreadPoolAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CatThreadPoolAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.CatThreadPool() into any of the following paths: \r\n - /_cat/thread_pool");
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClearScrollDispatch<T>(ElasticsearchPathInfo<ClearScrollRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClearScrollDispatch<T>(ElasticsearchPathInfo<ClearScrollRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /_search/scroll/{scroll_id}
 					if (!pathInfo.ScrollId.IsNullOrEmpty())
-						return this.Raw.ClearScroll<T>(pathInfo.ScrollId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClearScroll<T>(pathInfo.ScrollId,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -447,14 +447,14 @@ internal ElasticsearchResponse<T> ClearScrollDispatch<T>(ElasticsearchPathInfo<C
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClearScrollDispatchAsync<T>(ElasticsearchPathInfo<ClearScrollRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClearScrollDispatchAsync<T>(ElasticsearchPathInfo<ClearScrollRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /_search/scroll/{scroll_id}
 					if (!pathInfo.ScrollId.IsNullOrEmpty())
-						return this.Raw.ClearScrollAsync<T>(pathInfo.ScrollId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClearScrollAsync<T>(pathInfo.ScrollId,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -462,98 +462,98 @@ internal Task<ElasticsearchResponse<T>> ClearScrollDispatchAsync<T>(Elasticsearc
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterGetSettingsDispatch<T>(ElasticsearchPathInfo<ClusterGetSettingsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterGetSettingsDispatch<T>(ElasticsearchPathInfo<ClusterGetSettingsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/settings
-					return this.Raw.ClusterGetSettings<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterGetSettings<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterGetSettings() into any of the following paths: \r\n - /_cluster/settings");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterGetSettingsDispatchAsync<T>(ElasticsearchPathInfo<ClusterGetSettingsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterGetSettingsDispatchAsync<T>(ElasticsearchPathInfo<ClusterGetSettingsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/settings
-					return this.Raw.ClusterGetSettingsAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterGetSettingsAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterGetSettings() into any of the following paths: \r\n - /_cluster/settings");
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterHealthDispatch<T>(ElasticsearchPathInfo<ClusterHealthRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterHealthDispatch<T>(ElasticsearchPathInfo<ClusterHealthRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/health/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.ClusterHealth<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterHealth<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cluster/health
-					return this.Raw.ClusterHealth<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterHealth<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterHealth() into any of the following paths: \r\n - /_cluster/health\r\n - /_cluster/health/{index}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterHealthDispatchAsync<T>(ElasticsearchPathInfo<ClusterHealthRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterHealthDispatchAsync<T>(ElasticsearchPathInfo<ClusterHealthRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/health/{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.ClusterHealthAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterHealthAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cluster/health
-					return this.Raw.ClusterHealthAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterHealthAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterHealth() into any of the following paths: \r\n - /_cluster/health\r\n - /_cluster/health/{index}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterPendingTasksDispatch<T>(ElasticsearchPathInfo<ClusterPendingTasksRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterPendingTasksDispatch<T>(ElasticsearchPathInfo<ClusterPendingTasksRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/pending_tasks
-					return this.Raw.ClusterPendingTasks<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterPendingTasks<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterPendingTasks() into any of the following paths: \r\n - /_cluster/pending_tasks");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterPendingTasksDispatchAsync<T>(ElasticsearchPathInfo<ClusterPendingTasksRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterPendingTasksDispatchAsync<T>(ElasticsearchPathInfo<ClusterPendingTasksRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/pending_tasks
-					return this.Raw.ClusterPendingTasksAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterPendingTasksAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterPendingTasks() into any of the following paths: \r\n - /_cluster/pending_tasks");
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterPutSettingsDispatch<T>(ElasticsearchPathInfo<ClusterPutSettingsRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterPutSettingsDispatch<T>(ElasticsearchPathInfo<ClusterPutSettingsRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /_cluster/settings
 					if (body != null)
-						return this.Raw.ClusterPutSettings<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterPutSettings<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -561,14 +561,14 @@ internal ElasticsearchResponse<T> ClusterPutSettingsDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterPutSettingsDispatchAsync<T>(ElasticsearchPathInfo<ClusterPutSettingsRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterPutSettingsDispatchAsync<T>(ElasticsearchPathInfo<ClusterPutSettingsRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /_cluster/settings
 					if (body != null)
-						return this.Raw.ClusterPutSettingsAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterPutSettingsAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -576,14 +576,14 @@ internal Task<ElasticsearchResponse<T>> ClusterPutSettingsDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterRerouteDispatch<T>(ElasticsearchPathInfo<ClusterRerouteRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterRerouteDispatch<T>(ElasticsearchPathInfo<ClusterRerouteRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /_cluster/reroute
 					if (body != null)
-						return this.Raw.ClusterReroute<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterReroute<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -591,14 +591,14 @@ internal ElasticsearchResponse<T> ClusterRerouteDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterRerouteDispatchAsync<T>(ElasticsearchPathInfo<ClusterRerouteRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterRerouteDispatchAsync<T>(ElasticsearchPathInfo<ClusterRerouteRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /_cluster/reroute
 					if (body != null)
-						return this.Raw.ClusterRerouteAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterRerouteAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -606,158 +606,158 @@ internal Task<ElasticsearchResponse<T>> ClusterRerouteDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterStateDispatch<T>(ElasticsearchPathInfo<ClusterStateRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterStateDispatch<T>(ElasticsearchPathInfo<ClusterStateRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/state/{metric}/{index}
 					if (!pathInfo.Metric.IsNullOrEmpty() && !pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.ClusterState<T>(pathInfo.Metric,pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterState<T>(pathInfo.Metric,pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cluster/state/{metric}
 					if (!pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.ClusterState<T>(pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterState<T>(pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_cluster/state
-					return this.Raw.ClusterState<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterState<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterState() into any of the following paths: \r\n - /_cluster/state\r\n - /_cluster/state/{metric}\r\n - /_cluster/state/{metric}/{index}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterStateDispatchAsync<T>(ElasticsearchPathInfo<ClusterStateRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterStateDispatchAsync<T>(ElasticsearchPathInfo<ClusterStateRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/state/{metric}/{index}
 					if (!pathInfo.Metric.IsNullOrEmpty() && !pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.ClusterStateAsync<T>(pathInfo.Metric,pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterStateAsync<T>(pathInfo.Metric,pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cluster/state/{metric}
 					if (!pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.ClusterStateAsync<T>(pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterStateAsync<T>(pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_cluster/state
-					return this.Raw.ClusterStateAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterStateAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterState() into any of the following paths: \r\n - /_cluster/state\r\n - /_cluster/state/{metric}\r\n - /_cluster/state/{metric}/{index}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> ClusterStatsDispatch<T>(ElasticsearchPathInfo<ClusterStatsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ClusterStatsDispatch<T>(ElasticsearchPathInfo<ClusterStatsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/stats/nodes/{node_id}
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.ClusterStats<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterStats<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_cluster/stats
-					return this.Raw.ClusterStats<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterStats<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterStats() into any of the following paths: \r\n - /_cluster/stats\r\n - /_cluster/stats/nodes/{node_id}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ClusterStatsDispatchAsync<T>(ElasticsearchPathInfo<ClusterStatsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ClusterStatsDispatchAsync<T>(ElasticsearchPathInfo<ClusterStatsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/stats/nodes/{node_id}
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.ClusterStatsAsync<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ClusterStatsAsync<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_cluster/stats
-					return this.Raw.ClusterStatsAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ClusterStatsAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.ClusterStats() into any of the following paths: \r\n - /_cluster/stats\r\n - /_cluster/stats/nodes/{node_id}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CountDispatch<T>(ElasticsearchPathInfo<CountRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> CountDispatch<T>(ElasticsearchPathInfo<CountRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.Count<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Count<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_count
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.Count<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Count<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_count
 					if (body != null)
-						return this.Raw.Count<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Count<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.CountGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_count
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CountGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_count
-					return this.Raw.CountGet<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CountGet<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.Count() into any of the following paths: \r\n - /_count\r\n - /{index}/_count\r\n - /{index}/{type}/_count");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CountDispatchAsync<T>(ElasticsearchPathInfo<CountRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CountDispatchAsync<T>(ElasticsearchPathInfo<CountRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.CountAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_count
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.CountAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_count
 					if (body != null)
-						return this.Raw.CountAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.CountGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_count
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.CountGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_count
-					return this.Raw.CountGetAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.CountGetAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.Count() into any of the following paths: \r\n - /_count\r\n - /{index}/_count\r\n - /{index}/{type}/_count");
 		}
 		
 		
-		internal ElasticsearchResponse<T> CountPercolateDispatch<T>(ElasticsearchPathInfo<CountPercolateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> CountPercolateDispatch<T>(ElasticsearchPathInfo<CountPercolateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_percolate/count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.CountPercolateGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountPercolateGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					//GET /{index}/{type}/_percolate/count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.CountPercolateGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountPercolateGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_percolate/count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.CountPercolate<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountPercolate<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					//POST /{index}/{type}/_percolate/count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.CountPercolate<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountPercolate<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -765,26 +765,26 @@ internal ElasticsearchResponse<T> CountPercolateDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> CountPercolateDispatchAsync<T>(ElasticsearchPathInfo<CountPercolateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> CountPercolateDispatchAsync<T>(ElasticsearchPathInfo<CountPercolateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_percolate/count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.CountPercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountPercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					//GET /{index}/{type}/_percolate/count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.CountPercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountPercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_percolate/count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.CountPercolateAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountPercolateAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					//POST /{index}/{type}/_percolate/count
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.CountPercolateAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.CountPercolateAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -792,14 +792,14 @@ internal Task<ElasticsearchResponse<T>> CountPercolateDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> DeleteDispatch<T>(ElasticsearchPathInfo<DeleteRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> DeleteDispatch<T>(ElasticsearchPathInfo<DeleteRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.Delete<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Delete<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -807,14 +807,14 @@ internal ElasticsearchResponse<T> DeleteDispatch<T>(ElasticsearchPathInfo<Delete
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> DeleteDispatchAsync<T>(ElasticsearchPathInfo<DeleteRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> DeleteDispatchAsync<T>(ElasticsearchPathInfo<DeleteRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.DeleteAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.DeleteAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -822,17 +822,17 @@ internal Task<ElasticsearchResponse<T>> DeleteDispatchAsync<T>(ElasticsearchPath
 		}
 		
 		
-		internal ElasticsearchResponse<T> DeleteByQueryDispatch<T>(ElasticsearchPathInfo<DeleteByQueryRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> DeleteByQueryDispatch<T>(ElasticsearchPathInfo<DeleteByQueryRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/{type}/_query
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.DeleteByQuery<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.DeleteByQuery<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//DELETE /{index}/_query
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.DeleteByQuery<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.DeleteByQuery<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -840,17 +840,17 @@ internal ElasticsearchResponse<T> DeleteByQueryDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> DeleteByQueryDispatchAsync<T>(ElasticsearchPathInfo<DeleteByQueryRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> DeleteByQueryDispatchAsync<T>(ElasticsearchPathInfo<DeleteByQueryRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/{type}/_query
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.DeleteByQueryAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.DeleteByQueryAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//DELETE /{index}/_query
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.DeleteByQueryAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.DeleteByQueryAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -858,14 +858,14 @@ internal Task<ElasticsearchResponse<T>> DeleteByQueryDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> ExistsDispatch<T>(ElasticsearchPathInfo<ExistsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> ExistsDispatch<T>(ElasticsearchPathInfo<ExistsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.Exists<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Exists<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -873,14 +873,14 @@ internal ElasticsearchResponse<T> ExistsDispatch<T>(ElasticsearchPathInfo<Exists
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ExistsDispatchAsync<T>(ElasticsearchPathInfo<ExistsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ExistsDispatchAsync<T>(ElasticsearchPathInfo<ExistsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.ExistsAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ExistsAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -888,20 +888,20 @@ internal Task<ElasticsearchResponse<T>> ExistsDispatchAsync<T>(ElasticsearchPath
 		}
 		
 		
-		internal ElasticsearchResponse<T> ExplainDispatch<T>(ElasticsearchPathInfo<ExplainRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> ExplainDispatch<T>(ElasticsearchPathInfo<ExplainRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_explain
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.ExplainGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ExplainGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_explain
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.Explain<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Explain<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -909,20 +909,20 @@ internal ElasticsearchResponse<T> ExplainDispatch<T>(ElasticsearchPathInfo<Expla
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ExplainDispatchAsync<T>(ElasticsearchPathInfo<ExplainRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ExplainDispatchAsync<T>(ElasticsearchPathInfo<ExplainRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_explain
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.ExplainGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ExplainGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_explain
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.ExplainAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ExplainAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -930,14 +930,14 @@ internal Task<ElasticsearchResponse<T>> ExplainDispatchAsync<T>(ElasticsearchPat
 		}
 		
 		
-		internal ElasticsearchResponse<T> GetDispatch<T>(ElasticsearchPathInfo<GetRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> GetDispatch<T>(ElasticsearchPathInfo<GetRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.Get<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Get<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -945,14 +945,14 @@ internal ElasticsearchResponse<T> GetDispatch<T>(ElasticsearchPathInfo<GetReques
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> GetDispatchAsync<T>(ElasticsearchPathInfo<GetRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> GetDispatchAsync<T>(ElasticsearchPathInfo<GetRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.GetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.GetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -960,14 +960,14 @@ internal Task<ElasticsearchResponse<T>> GetDispatchAsync<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal ElasticsearchResponse<T> GetSourceDispatch<T>(ElasticsearchPathInfo<SourceRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> GetSourceDispatch<T>(ElasticsearchPathInfo<SourceRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_source
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.GetSource<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.GetSource<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -975,14 +975,14 @@ internal ElasticsearchResponse<T> GetSourceDispatch<T>(ElasticsearchPathInfo<Sou
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> GetSourceDispatchAsync<T>(ElasticsearchPathInfo<SourceRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> GetSourceDispatchAsync<T>(ElasticsearchPathInfo<SourceRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_source
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.GetSourceAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.GetSourceAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -990,26 +990,26 @@ internal Task<ElasticsearchResponse<T>> GetSourceDispatchAsync<T>(ElasticsearchP
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndexDispatch<T>(ElasticsearchPathInfo<IndexRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndexDispatch<T>(ElasticsearchPathInfo<IndexRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.Index<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Index<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					//POST /{index}/{type}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.Index<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Index<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.IndexPut<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndexPut<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					//PUT /{index}/{type}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndexPut<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndexPut<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1017,26 +1017,26 @@ internal ElasticsearchResponse<T> IndexDispatch<T>(ElasticsearchPathInfo<IndexRe
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndexDispatchAsync<T>(ElasticsearchPathInfo<IndexRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndexDispatchAsync<T>(ElasticsearchPathInfo<IndexRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.IndexAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndexAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					//POST /{index}/{type}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndexAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndexAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/{type}/{id}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.IndexPutAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndexPutAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					//PUT /{index}/{type}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndexPutAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndexPutAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1044,24 +1044,24 @@ internal Task<ElasticsearchResponse<T>> IndexDispatchAsync<T>(ElasticsearchPathI
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesAnalyzeDispatch<T>(ElasticsearchPathInfo<AnalyzeRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesAnalyzeDispatch<T>(ElasticsearchPathInfo<AnalyzeRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_analyze
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesAnalyzeGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesAnalyzeGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_analyze
-					return this.Raw.IndicesAnalyzeGetForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesAnalyzeGetForAll<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_analyze
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesAnalyze<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesAnalyze<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_analyze
 					if (body != null)
-						return this.Raw.IndicesAnalyzeForAll<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesAnalyzeForAll<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1069,24 +1069,24 @@ internal ElasticsearchResponse<T> IndicesAnalyzeDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesAnalyzeDispatchAsync<T>(ElasticsearchPathInfo<AnalyzeRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesAnalyzeDispatchAsync<T>(ElasticsearchPathInfo<AnalyzeRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_analyze
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesAnalyzeGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesAnalyzeGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_analyze
-					return this.Raw.IndicesAnalyzeGetForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesAnalyzeGetForAllAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_analyze
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesAnalyzeAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesAnalyzeAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_analyze
 					if (body != null)
-						return this.Raw.IndicesAnalyzeForAllAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesAnalyzeForAllAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1094,60 +1094,60 @@ internal Task<ElasticsearchResponse<T>> IndicesAnalyzeDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesClearCacheDispatch<T>(ElasticsearchPathInfo<ClearCacheRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesClearCacheDispatch<T>(ElasticsearchPathInfo<ClearCacheRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_cache/clear
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesClearCache<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesClearCache<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_cache/clear
-					return this.Raw.IndicesClearCacheForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesClearCacheForAll<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_cache/clear
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesClearCacheGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesClearCacheGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cache/clear
-					return this.Raw.IndicesClearCacheGetForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesClearCacheGetForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesClearCache() into any of the following paths: \r\n - /_cache/clear\r\n - /{index}/_cache/clear");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesClearCacheDispatchAsync<T>(ElasticsearchPathInfo<ClearCacheRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesClearCacheDispatchAsync<T>(ElasticsearchPathInfo<ClearCacheRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_cache/clear
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesClearCacheAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesClearCacheAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_cache/clear
-					return this.Raw.IndicesClearCacheForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesClearCacheForAllAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_cache/clear
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesClearCacheGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesClearCacheGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_cache/clear
-					return this.Raw.IndicesClearCacheGetForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesClearCacheGetForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesClearCache() into any of the following paths: \r\n - /_cache/clear\r\n - /{index}/_cache/clear");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesCloseDispatch<T>(ElasticsearchPathInfo<CloseIndexRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesCloseDispatch<T>(ElasticsearchPathInfo<CloseIndexRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_close
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesClose<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesClose<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1155,14 +1155,14 @@ internal ElasticsearchResponse<T> IndicesCloseDispatch<T>(ElasticsearchPathInfo<
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesCloseDispatchAsync<T>(ElasticsearchPathInfo<CloseIndexRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesCloseDispatchAsync<T>(ElasticsearchPathInfo<CloseIndexRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_close
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesCloseAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesCloseAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1170,20 +1170,20 @@ internal Task<ElasticsearchResponse<T>> IndicesCloseDispatchAsync<T>(Elasticsear
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesCreateDispatch<T>(ElasticsearchPathInfo<CreateIndexRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesCreateDispatch<T>(ElasticsearchPathInfo<CreateIndexRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesCreate<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesCreate<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesCreatePost<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesCreatePost<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1191,20 +1191,20 @@ internal ElasticsearchResponse<T> IndicesCreateDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesCreateDispatchAsync<T>(ElasticsearchPathInfo<CreateIndexRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesCreateDispatchAsync<T>(ElasticsearchPathInfo<CreateIndexRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesCreateAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesCreateAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesCreatePostAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesCreatePostAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1212,14 +1212,14 @@ internal Task<ElasticsearchResponse<T>> IndicesCreateDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteDispatch<T>(ElasticsearchPathInfo<DeleteIndexRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteDispatch<T>(ElasticsearchPathInfo<DeleteIndexRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesDelete<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDelete<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1227,14 +1227,14 @@ internal ElasticsearchResponse<T> IndicesDeleteDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteDispatchAsync<T>(ElasticsearchPathInfo<DeleteIndexRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteDispatchAsync<T>(ElasticsearchPathInfo<DeleteIndexRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesDeleteAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDeleteAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1242,14 +1242,14 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteAliasDispatch<T>(ElasticsearchPathInfo<IndicesDeleteAliasRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteAliasDispatch<T>(ElasticsearchPathInfo<IndicesDeleteAliasRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesDeleteAlias<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDeleteAlias<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1257,14 +1257,14 @@ internal ElasticsearchResponse<T> IndicesDeleteAliasDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesDeleteAliasRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesDeleteAliasRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesDeleteAliasAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDeleteAliasAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1272,14 +1272,14 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteAliasDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteMappingDispatch<T>(ElasticsearchPathInfo<DeleteMappingRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteMappingDispatch<T>(ElasticsearchPathInfo<DeleteMappingRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/{type}/_mapping
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesDeleteMapping<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDeleteMapping<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1287,14 +1287,14 @@ internal ElasticsearchResponse<T> IndicesDeleteMappingDispatch<T>(ElasticsearchP
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteMappingDispatchAsync<T>(ElasticsearchPathInfo<DeleteMappingRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteMappingDispatchAsync<T>(ElasticsearchPathInfo<DeleteMappingRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/{type}/_mapping
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesDeleteMappingAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDeleteMappingAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1302,14 +1302,14 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteMappingDispatchAsync<T>(Ela
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteTemplateDispatch<T>(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteTemplateDispatch<T>(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesDeleteTemplateForAll<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDeleteTemplateForAll<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1317,14 +1317,14 @@ internal ElasticsearchResponse<T> IndicesDeleteTemplateDispatch<T>(Elasticsearch
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteTemplateDispatchAsync<T>(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteTemplateDispatchAsync<T>(ElasticsearchPathInfo<DeleteTemplateRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesDeleteTemplateForAllAsync<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDeleteTemplateForAllAsync<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1332,14 +1332,14 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteTemplateDispatchAsync<T>(El
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesDeleteWarmerDispatch<T>(ElasticsearchPathInfo<DeleteWarmerRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesDeleteWarmerDispatch<T>(ElasticsearchPathInfo<DeleteWarmerRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesDeleteWarmer<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDeleteWarmer<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1347,14 +1347,14 @@ internal ElasticsearchResponse<T> IndicesDeleteWarmerDispatch<T>(ElasticsearchPa
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesDeleteWarmerDispatchAsync<T>(ElasticsearchPathInfo<DeleteWarmerRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesDeleteWarmerDispatchAsync<T>(ElasticsearchPathInfo<DeleteWarmerRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /{index}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesDeleteWarmerAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesDeleteWarmerAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1362,14 +1362,14 @@ internal Task<ElasticsearchResponse<T>> IndicesDeleteWarmerDispatchAsync<T>(Elas
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesExistsDispatch<T>(ElasticsearchPathInfo<IndexExistsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesExistsDispatch<T>(ElasticsearchPathInfo<IndexExistsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesExists<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExists<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1377,14 +1377,14 @@ internal ElasticsearchResponse<T> IndicesExistsDispatch<T>(ElasticsearchPathInfo
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesExistsDispatchAsync<T>(ElasticsearchPathInfo<IndexExistsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesExistsDispatchAsync<T>(ElasticsearchPathInfo<IndexExistsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /{index}
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesExistsAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1392,20 +1392,20 @@ internal Task<ElasticsearchResponse<T>> IndicesExistsDispatchAsync<T>(Elasticsea
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesExistsAliasDispatch<T>(ElasticsearchPathInfo<IndicesExistsAliasRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesExistsAliasDispatch<T>(ElasticsearchPathInfo<IndicesExistsAliasRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesExistsAlias<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsAlias<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//HEAD /_alias/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesExistsAliasForAll<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsAliasForAll<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//HEAD /{index}/_alias
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesExistsAlias<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsAlias<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1413,20 +1413,20 @@ internal ElasticsearchResponse<T> IndicesExistsAliasDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesExistsAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsAliasRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesExistsAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsAliasRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesExistsAliasAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsAliasAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//HEAD /_alias/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesExistsAliasForAllAsync<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsAliasForAllAsync<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//HEAD /{index}/_alias
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesExistsAliasAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsAliasAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1434,14 +1434,14 @@ internal Task<ElasticsearchResponse<T>> IndicesExistsAliasDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesExistsTemplateDispatch<T>(ElasticsearchPathInfo<IndicesExistsTemplateRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesExistsTemplateDispatch<T>(ElasticsearchPathInfo<IndicesExistsTemplateRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesExistsTemplateForAll<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsTemplateForAll<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1449,14 +1449,14 @@ internal ElasticsearchResponse<T> IndicesExistsTemplateDispatch<T>(Elasticsearch
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesExistsTemplateDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsTemplateRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesExistsTemplateDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsTemplateRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesExistsTemplateForAllAsync<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsTemplateForAllAsync<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1464,14 +1464,14 @@ internal Task<ElasticsearchResponse<T>> IndicesExistsTemplateDispatchAsync<T>(El
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesExistsTypeDispatch<T>(ElasticsearchPathInfo<IndicesExistsTypeRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesExistsTypeDispatch<T>(ElasticsearchPathInfo<IndicesExistsTypeRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /{index}/{type}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesExistsType<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsType<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1479,14 +1479,14 @@ internal ElasticsearchResponse<T> IndicesExistsTypeDispatch<T>(ElasticsearchPath
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesExistsTypeDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsTypeRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesExistsTypeDispatchAsync<T>(ElasticsearchPathInfo<IndicesExistsTypeRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /{index}/{type}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesExistsTypeAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesExistsTypeAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1494,157 +1494,157 @@ internal Task<ElasticsearchResponse<T>> IndicesExistsTypeDispatchAsync<T>(Elasti
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesFlushDispatch<T>(ElasticsearchPathInfo<FlushRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesFlushDispatch<T>(ElasticsearchPathInfo<FlushRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_flush
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesFlush<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesFlush<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_flush
-					return this.Raw.IndicesFlushForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesFlushForAll<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_flush
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesFlushGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesFlushGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_flush
-					return this.Raw.IndicesFlushGetForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesFlushGetForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesFlush() into any of the following paths: \r\n - /_flush\r\n - /{index}/_flush");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesFlushDispatchAsync<T>(ElasticsearchPathInfo<FlushRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesFlushDispatchAsync<T>(ElasticsearchPathInfo<FlushRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_flush
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesFlushAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesFlushAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_flush
-					return this.Raw.IndicesFlushForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesFlushForAllAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_flush
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesFlushGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesFlushGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_flush
-					return this.Raw.IndicesFlushGetForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesFlushGetForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesFlush() into any of the following paths: \r\n - /_flush\r\n - /{index}/_flush");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetAliasDispatch<T>(ElasticsearchPathInfo<GetAliasesRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetAliasDispatch<T>(ElasticsearchPathInfo<GetAliasesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetAlias<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAlias<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_alias/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliasForAll<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliasForAll<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_alias
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetAlias<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAlias<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_alias
-					return this.Raw.IndicesGetAliasForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetAliasForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetAlias() into any of the following paths: \r\n - /_alias\r\n - /_alias/{name}\r\n - /{index}/_alias/{name}\r\n - /{index}/_alias");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetAliasDispatchAsync<T>(ElasticsearchPathInfo<GetAliasesRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetAliasDispatchAsync<T>(ElasticsearchPathInfo<GetAliasesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliasAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliasAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_alias/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliasForAllAsync<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliasForAllAsync<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_alias
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliasAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliasAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_alias
-					return this.Raw.IndicesGetAliasForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetAliasForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetAlias() into any of the following paths: \r\n - /_alias\r\n - /_alias/{name}\r\n - /{index}/_alias/{name}\r\n - /{index}/_alias");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetAliasesDispatch<T>(ElasticsearchPathInfo<IndicesGetAliasesRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetAliasesDispatch<T>(ElasticsearchPathInfo<IndicesGetAliasesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_aliases/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliases<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliases<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_aliases
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliases<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliases<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_aliases/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliasesForAll<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliasesForAll<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_aliases
-					return this.Raw.IndicesGetAliasesForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetAliasesForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetAliases() into any of the following paths: \r\n - /_aliases\r\n - /{index}/_aliases\r\n - /{index}/_aliases/{name}\r\n - /_aliases/{name}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetAliasesDispatchAsync<T>(ElasticsearchPathInfo<IndicesGetAliasesRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetAliasesDispatchAsync<T>(ElasticsearchPathInfo<IndicesGetAliasesRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_aliases/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliasesAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliasesAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_aliases
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliasesAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliasesAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_aliases/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetAliasesForAllAsync<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetAliasesForAllAsync<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_aliases
-					return this.Raw.IndicesGetAliasesForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetAliasesForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetAliases() into any of the following paths: \r\n - /_aliases\r\n - /{index}/_aliases\r\n - /{index}/_aliases/{name}\r\n - /_aliases/{name}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetFieldMappingDispatch<T>(ElasticsearchPathInfo<IndicesGetFieldMappingRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetFieldMappingDispatch<T>(ElasticsearchPathInfo<IndicesGetFieldMappingRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_mapping/{type}/field/{field}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Field.IsNullOrEmpty())
-						return this.Raw.IndicesGetFieldMapping<T>(pathInfo.Index,pathInfo.Type,pathInfo.Field,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetFieldMapping<T>(pathInfo.Index,pathInfo.Type,pathInfo.Field,u => pathInfo.RequestParameters);
 					//GET /{index}/_mapping/field/{field}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Field.IsNullOrEmpty())
-						return this.Raw.IndicesGetFieldMapping<T>(pathInfo.Index,pathInfo.Field,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetFieldMapping<T>(pathInfo.Index,pathInfo.Field,u => pathInfo.RequestParameters);
 					//GET /_mapping/{type}/field/{field}
 					if (!pathInfo.Type.IsNullOrEmpty() && !pathInfo.Field.IsNullOrEmpty())
-						return this.Raw.IndicesGetFieldMappingForAll<T>(pathInfo.Type,pathInfo.Field,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetFieldMappingForAll<T>(pathInfo.Type,pathInfo.Field,u => pathInfo.RequestParameters);
 					//GET /_mapping/field/{field}
 					if (!pathInfo.Field.IsNullOrEmpty())
-						return this.Raw.IndicesGetFieldMappingForAll<T>(pathInfo.Field,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetFieldMappingForAll<T>(pathInfo.Field,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1652,23 +1652,23 @@ internal ElasticsearchResponse<T> IndicesGetFieldMappingDispatch<T>(Elasticsearc
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetFieldMappingDispatchAsync<T>(ElasticsearchPathInfo<IndicesGetFieldMappingRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetFieldMappingDispatchAsync<T>(ElasticsearchPathInfo<IndicesGetFieldMappingRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_mapping/{type}/field/{field}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Field.IsNullOrEmpty())
-						return this.Raw.IndicesGetFieldMappingAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Field,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetFieldMappingAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Field,u => pathInfo.RequestParameters);
 					//GET /{index}/_mapping/field/{field}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Field.IsNullOrEmpty())
-						return this.Raw.IndicesGetFieldMappingAsync<T>(pathInfo.Index,pathInfo.Field,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetFieldMappingAsync<T>(pathInfo.Index,pathInfo.Field,u => pathInfo.RequestParameters);
 					//GET /_mapping/{type}/field/{field}
 					if (!pathInfo.Type.IsNullOrEmpty() && !pathInfo.Field.IsNullOrEmpty())
-						return this.Raw.IndicesGetFieldMappingForAllAsync<T>(pathInfo.Type,pathInfo.Field,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetFieldMappingForAllAsync<T>(pathInfo.Type,pathInfo.Field,u => pathInfo.RequestParameters);
 					//GET /_mapping/field/{field}
 					if (!pathInfo.Field.IsNullOrEmpty())
-						return this.Raw.IndicesGetFieldMappingForAllAsync<T>(pathInfo.Field,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetFieldMappingForAllAsync<T>(pathInfo.Field,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1676,184 +1676,184 @@ internal Task<ElasticsearchResponse<T>> IndicesGetFieldMappingDispatchAsync<T>(E
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetMappingDispatch<T>(ElasticsearchPathInfo<GetMappingRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetMappingDispatch<T>(ElasticsearchPathInfo<GetMappingRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_mapping/{type}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesGetMapping<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetMapping<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_mapping
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetMapping<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetMapping<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_mapping/{type}
 					if (!pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesGetMappingForAll<T>(pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetMappingForAll<T>(pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /_mapping
-					return this.Raw.IndicesGetMappingForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetMappingForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetMapping() into any of the following paths: \r\n - /_mapping\r\n - /{index}/_mapping\r\n - /_mapping/{type}\r\n - /{index}/_mapping/{type}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetMappingDispatchAsync<T>(ElasticsearchPathInfo<GetMappingRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetMappingDispatchAsync<T>(ElasticsearchPathInfo<GetMappingRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_mapping/{type}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesGetMappingAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetMappingAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_mapping
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetMappingAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetMappingAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_mapping/{type}
 					if (!pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesGetMappingForAllAsync<T>(pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetMappingForAllAsync<T>(pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /_mapping
-					return this.Raw.IndicesGetMappingForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetMappingForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetMapping() into any of the following paths: \r\n - /_mapping\r\n - /{index}/_mapping\r\n - /_mapping/{type}\r\n - /{index}/_mapping/{type}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetSettingsDispatch<T>(ElasticsearchPathInfo<GetIndexSettingsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetSettingsDispatch<T>(ElasticsearchPathInfo<GetIndexSettingsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_settings/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetSettings<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetSettings<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_settings
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetSettings<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetSettings<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_settings/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetSettingsForAll<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetSettingsForAll<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_settings
-					return this.Raw.IndicesGetSettingsForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetSettingsForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetSettings() into any of the following paths: \r\n - /_settings\r\n - /{index}/_settings\r\n - /{index}/_settings/{name}\r\n - /_settings/{name}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetSettingsDispatchAsync<T>(ElasticsearchPathInfo<GetIndexSettingsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetSettingsDispatchAsync<T>(ElasticsearchPathInfo<GetIndexSettingsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_settings/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetSettingsAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetSettingsAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_settings
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetSettingsAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetSettingsAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_settings/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetSettingsForAllAsync<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetSettingsForAllAsync<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_settings
-					return this.Raw.IndicesGetSettingsForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetSettingsForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetSettings() into any of the following paths: \r\n - /_settings\r\n - /{index}/_settings\r\n - /{index}/_settings/{name}\r\n - /_settings/{name}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetTemplateDispatch<T>(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetTemplateDispatch<T>(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetTemplateForAll<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetTemplateForAll<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_template
-					return this.Raw.IndicesGetTemplateForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetTemplateForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetTemplate() into any of the following paths: \r\n - /_template\r\n - /_template/{name}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetTemplateDispatchAsync<T>(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetTemplateDispatchAsync<T>(ElasticsearchPathInfo<GetTemplateRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetTemplateForAllAsync<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetTemplateForAllAsync<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_template
-					return this.Raw.IndicesGetTemplateForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetTemplateForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetTemplate() into any of the following paths: \r\n - /_template\r\n - /_template/{name}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesGetWarmerDispatch<T>(ElasticsearchPathInfo<GetWarmerRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesGetWarmerDispatch<T>(ElasticsearchPathInfo<GetWarmerRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetWarmer<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetWarmer<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetWarmer<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetWarmer<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_warmer
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetWarmer<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetWarmer<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_warmer/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetWarmerForAll<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetWarmerForAll<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_warmer
-					return this.Raw.IndicesGetWarmerForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetWarmerForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetWarmer() into any of the following paths: \r\n - /_warmer\r\n - /{index}/_warmer\r\n - /{index}/_warmer/{name}\r\n - /_warmer/{name}\r\n - /{index}/{type}/_warmer/{name}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesGetWarmerDispatchAsync<T>(ElasticsearchPathInfo<GetWarmerRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesGetWarmerDispatchAsync<T>(ElasticsearchPathInfo<GetWarmerRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetWarmerAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetWarmerAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetWarmerAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetWarmerAsync<T>(pathInfo.Index,pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /{index}/_warmer
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesGetWarmerAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetWarmerAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_warmer/{name}
 					if (!pathInfo.Name.IsNullOrEmpty())
-						return this.Raw.IndicesGetWarmerForAllAsync<T>(pathInfo.Name,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesGetWarmerForAllAsync<T>(pathInfo.Name,u => pathInfo.RequestParameters);
 					//GET /_warmer
-					return this.Raw.IndicesGetWarmerForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesGetWarmerForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesGetWarmer() into any of the following paths: \r\n - /_warmer\r\n - /{index}/_warmer\r\n - /{index}/_warmer/{name}\r\n - /_warmer/{name}\r\n - /{index}/{type}/_warmer/{name}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesOpenDispatch<T>(ElasticsearchPathInfo<OpenIndexRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesOpenDispatch<T>(ElasticsearchPathInfo<OpenIndexRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_open
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesOpen<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesOpen<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1861,14 +1861,14 @@ internal ElasticsearchResponse<T> IndicesOpenDispatch<T>(ElasticsearchPathInfo<O
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesOpenDispatchAsync<T>(ElasticsearchPathInfo<OpenIndexRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesOpenDispatchAsync<T>(ElasticsearchPathInfo<OpenIndexRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_open
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesOpenAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesOpenAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1876,72 +1876,72 @@ internal Task<ElasticsearchResponse<T>> IndicesOpenDispatchAsync<T>(Elasticsearc
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesOptimizeDispatch<T>(ElasticsearchPathInfo<OptimizeRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesOptimizeDispatch<T>(ElasticsearchPathInfo<OptimizeRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_optimize
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesOptimize<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesOptimize<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_optimize
-					return this.Raw.IndicesOptimizeForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesOptimizeForAll<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_optimize
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesOptimizeGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesOptimizeGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_optimize
-					return this.Raw.IndicesOptimizeGetForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesOptimizeGetForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesOptimize() into any of the following paths: \r\n - /_optimize\r\n - /{index}/_optimize");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesOptimizeDispatchAsync<T>(ElasticsearchPathInfo<OptimizeRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesOptimizeDispatchAsync<T>(ElasticsearchPathInfo<OptimizeRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_optimize
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesOptimizeAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesOptimizeAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_optimize
-					return this.Raw.IndicesOptimizeForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesOptimizeForAllAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_optimize
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesOptimizeGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesOptimizeGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_optimize
-					return this.Raw.IndicesOptimizeGetForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesOptimizeGetForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesOptimize() into any of the following paths: \r\n - /_optimize\r\n - /{index}/_optimize");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutAliasDispatch<T>(ElasticsearchPathInfo<IndicesPutAliasRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutAliasDispatch<T>(ElasticsearchPathInfo<IndicesPutAliasRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutAlias<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutAlias<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//PUT /_alias/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutAliasForAll<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutAliasForAll<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutAliasPost<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutAliasPost<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//POST /_alias/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutAliasPostForAll<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutAliasPostForAll<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1949,26 +1949,26 @@ internal ElasticsearchResponse<T> IndicesPutAliasDispatch<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesPutAliasRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutAliasDispatchAsync<T>(ElasticsearchPathInfo<IndicesPutAliasRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutAliasAsync<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutAliasAsync<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//PUT /_alias/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutAliasForAllAsync<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutAliasForAllAsync<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_alias/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutAliasPostAsync<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutAliasPostAsync<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//POST /_alias/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutAliasPostForAllAsync<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutAliasPostForAllAsync<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -1976,26 +1976,26 @@ internal Task<ElasticsearchResponse<T>> IndicesPutAliasDispatchAsync<T>(Elastics
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutMappingDispatch<T>(ElasticsearchPathInfo<PutMappingRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutMappingDispatch<T>(ElasticsearchPathInfo<PutMappingRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/{type}/_mapping
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutMapping<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutMapping<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//PUT /_mapping/{type}
 					if (!pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutMappingForAll<T>(pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutMappingForAll<T>(pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_mapping
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutMappingPost<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutMappingPost<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /_mapping/{type}
 					if (!pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutMappingPostForAll<T>(pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutMappingPostForAll<T>(pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2003,26 +2003,26 @@ internal ElasticsearchResponse<T> IndicesPutMappingDispatch<T>(ElasticsearchPath
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutMappingDispatchAsync<T>(ElasticsearchPathInfo<PutMappingRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutMappingDispatchAsync<T>(ElasticsearchPathInfo<PutMappingRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/{type}/_mapping
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutMappingAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutMappingAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//PUT /_mapping/{type}
 					if (!pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutMappingForAllAsync<T>(pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutMappingForAllAsync<T>(pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_mapping
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutMappingPostAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutMappingPostAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /_mapping/{type}
 					if (!pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutMappingPostForAllAsync<T>(pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutMappingPostForAllAsync<T>(pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2030,17 +2030,17 @@ internal Task<ElasticsearchResponse<T>> IndicesPutMappingDispatchAsync<T>(Elasti
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutSettingsDispatch<T>(ElasticsearchPathInfo<UpdateSettingsRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutSettingsDispatch<T>(ElasticsearchPathInfo<UpdateSettingsRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/_settings
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutSettings<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutSettings<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//PUT /_settings
 					if (body != null)
-						return this.Raw.IndicesPutSettingsForAll<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutSettingsForAll<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2048,17 +2048,17 @@ internal ElasticsearchResponse<T> IndicesPutSettingsDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutSettingsDispatchAsync<T>(ElasticsearchPathInfo<UpdateSettingsRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutSettingsDispatchAsync<T>(ElasticsearchPathInfo<UpdateSettingsRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/_settings
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutSettingsAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutSettingsAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//PUT /_settings
 					if (body != null)
-						return this.Raw.IndicesPutSettingsForAllAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutSettingsForAllAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2066,20 +2066,20 @@ internal Task<ElasticsearchResponse<T>> IndicesPutSettingsDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutTemplateDispatch<T>(ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutTemplateDispatch<T>(ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutTemplateForAll<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutTemplateForAll<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutTemplatePostForAll<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutTemplatePostForAll<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2087,20 +2087,20 @@ internal ElasticsearchResponse<T> IndicesPutTemplateDispatch<T>(ElasticsearchPat
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutTemplateDispatchAsync<T>(ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutTemplateDispatchAsync<T>(ElasticsearchPathInfo<PutTemplateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutTemplateForAllAsync<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutTemplateForAllAsync<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /_template/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutTemplatePostForAllAsync<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutTemplatePostForAllAsync<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2108,32 +2108,32 @@ internal Task<ElasticsearchResponse<T>> IndicesPutTemplateDispatchAsync<T>(Elast
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesPutWarmerDispatch<T>(ElasticsearchPathInfo<PutWarmerRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesPutWarmerDispatch<T>(ElasticsearchPathInfo<PutWarmerRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/{type}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmer<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmer<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//PUT /{index}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmer<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmer<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//PUT /_warmer/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerForAll<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerForAll<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerPost<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerPost<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerPost<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerPost<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//POST /_warmer/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerPostForAll<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerPostForAll<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2141,32 +2141,32 @@ internal ElasticsearchResponse<T> IndicesPutWarmerDispatch<T>(ElasticsearchPathI
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesPutWarmerDispatchAsync<T>(ElasticsearchPathInfo<PutWarmerRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesPutWarmerDispatchAsync<T>(ElasticsearchPathInfo<PutWarmerRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /{index}/{type}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//PUT /{index}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerAsync<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerAsync<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//PUT /_warmer/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerForAllAsync<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerForAllAsync<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerPostAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerPostAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_warmer/{name}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerPostAsync<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerPostAsync<T>(pathInfo.Index,pathInfo.Name,body,u => pathInfo.RequestParameters);
 					//POST /_warmer/{name}
 					if (!pathInfo.Name.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesPutWarmerPostForAllAsync<T>(pathInfo.Name,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesPutWarmerPostForAllAsync<T>(pathInfo.Name,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2174,200 +2174,200 @@ internal Task<ElasticsearchResponse<T>> IndicesPutWarmerDispatchAsync<T>(Elastic
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesRefreshDispatch<T>(ElasticsearchPathInfo<RefreshRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesRefreshDispatch<T>(ElasticsearchPathInfo<RefreshRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_refresh
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesRefresh<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesRefresh<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_refresh
-					return this.Raw.IndicesRefreshForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesRefreshForAll<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_refresh
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesRefreshGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesRefreshGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_refresh
-					return this.Raw.IndicesRefreshGetForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesRefreshGetForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesRefresh() into any of the following paths: \r\n - /_refresh\r\n - /{index}/_refresh");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesRefreshDispatchAsync<T>(ElasticsearchPathInfo<RefreshRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesRefreshDispatchAsync<T>(ElasticsearchPathInfo<RefreshRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_refresh
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesRefreshAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesRefreshAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_refresh
-					return this.Raw.IndicesRefreshForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesRefreshForAllAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_refresh
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesRefreshGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesRefreshGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_refresh
-					return this.Raw.IndicesRefreshGetForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesRefreshGetForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesRefresh() into any of the following paths: \r\n - /_refresh\r\n - /{index}/_refresh");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesSegmentsDispatch<T>(ElasticsearchPathInfo<SegmentsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesSegmentsDispatch<T>(ElasticsearchPathInfo<SegmentsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_segments
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesSegments<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesSegments<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_segments
-					return this.Raw.IndicesSegmentsForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesSegmentsForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesSegments() into any of the following paths: \r\n - /_segments\r\n - /{index}/_segments");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesSegmentsDispatchAsync<T>(ElasticsearchPathInfo<SegmentsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesSegmentsDispatchAsync<T>(ElasticsearchPathInfo<SegmentsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_segments
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesSegmentsAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesSegmentsAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_segments
-					return this.Raw.IndicesSegmentsForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesSegmentsForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesSegments() into any of the following paths: \r\n - /_segments\r\n - /{index}/_segments");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesSnapshotIndexDispatch<T>(ElasticsearchPathInfo<SnapshotRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesSnapshotIndexDispatch<T>(ElasticsearchPathInfo<SnapshotRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_gateway/snapshot
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesSnapshotIndex<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesSnapshotIndex<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_gateway/snapshot
-					return this.Raw.IndicesSnapshotIndexForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesSnapshotIndexForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesSnapshotIndex() into any of the following paths: \r\n - /_gateway/snapshot\r\n - /{index}/_gateway/snapshot");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesSnapshotIndexDispatchAsync<T>(ElasticsearchPathInfo<SnapshotRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesSnapshotIndexDispatchAsync<T>(ElasticsearchPathInfo<SnapshotRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_gateway/snapshot
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesSnapshotIndexAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesSnapshotIndexAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//POST /_gateway/snapshot
-					return this.Raw.IndicesSnapshotIndexForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesSnapshotIndexForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesSnapshotIndex() into any of the following paths: \r\n - /_gateway/snapshot\r\n - /{index}/_gateway/snapshot");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesStatsDispatch<T>(ElasticsearchPathInfo<IndicesStatsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesStatsDispatch<T>(ElasticsearchPathInfo<IndicesStatsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_stats/{metric}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.IndicesStats<T>(pathInfo.Index,pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesStats<T>(pathInfo.Index,pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_stats/{metric}
 					if (!pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.IndicesStatsForAll<T>(pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesStatsForAll<T>(pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /{index}/_stats
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesStats<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesStats<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_stats
-					return this.Raw.IndicesStatsForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesStatsForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesStats() into any of the following paths: \r\n - /_stats\r\n - /_stats/{metric}\r\n - /{index}/_stats\r\n - /{index}/_stats/{metric}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesStatsDispatchAsync<T>(ElasticsearchPathInfo<IndicesStatsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesStatsDispatchAsync<T>(ElasticsearchPathInfo<IndicesStatsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_stats/{metric}
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.IndicesStatsAsync<T>(pathInfo.Index,pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesStatsAsync<T>(pathInfo.Index,pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_stats/{metric}
 					if (!pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.IndicesStatsForAllAsync<T>(pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesStatsForAllAsync<T>(pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /{index}/_stats
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesStatsAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesStatsAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_stats
-					return this.Raw.IndicesStatsForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesStatsForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesStats() into any of the following paths: \r\n - /_stats\r\n - /_stats/{metric}\r\n - /{index}/_stats\r\n - /{index}/_stats/{metric}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesStatusDispatch<T>(ElasticsearchPathInfo<IndicesStatusRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesStatusDispatch<T>(ElasticsearchPathInfo<IndicesStatusRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_status
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesStatus<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesStatus<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_status
-					return this.Raw.IndicesStatusForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesStatusForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesStatus() into any of the following paths: \r\n - /_status\r\n - /{index}/_status");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesStatusDispatchAsync<T>(ElasticsearchPathInfo<IndicesStatusRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesStatusDispatchAsync<T>(ElasticsearchPathInfo<IndicesStatusRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_status
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesStatusAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesStatusAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_status
-					return this.Raw.IndicesStatusForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesStatusForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.IndicesStatus() into any of the following paths: \r\n - /_status\r\n - /{index}/_status");
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesUpdateAliasesDispatch<T>(ElasticsearchPathInfo<AliasRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesUpdateAliasesDispatch<T>(ElasticsearchPathInfo<AliasRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /_aliases
 					if (body != null)
-						return this.Raw.IndicesUpdateAliasesForAll<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesUpdateAliasesForAll<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2375,14 +2375,14 @@ internal ElasticsearchResponse<T> IndicesUpdateAliasesDispatch<T>(ElasticsearchP
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesUpdateAliasesDispatchAsync<T>(ElasticsearchPathInfo<AliasRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesUpdateAliasesDispatchAsync<T>(ElasticsearchPathInfo<AliasRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /_aliases
 					if (body != null)
-						return this.Raw.IndicesUpdateAliasesForAllAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesUpdateAliasesForAllAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2390,30 +2390,30 @@ internal Task<ElasticsearchResponse<T>> IndicesUpdateAliasesDispatchAsync<T>(Ela
 		}
 		
 		
-		internal ElasticsearchResponse<T> IndicesValidateQueryDispatch<T>(ElasticsearchPathInfo<ValidateQueryRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> IndicesValidateQueryDispatch<T>(ElasticsearchPathInfo<ValidateQueryRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_validate/query
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesValidateQueryGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQueryGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_validate/query
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesValidateQueryGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQueryGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_validate/query
-					return this.Raw.IndicesValidateQueryGetForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesValidateQueryGetForAll<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_validate/query
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesValidateQuery<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQuery<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_validate/query
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesValidateQuery<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQuery<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_validate/query
 					if (body != null)
-						return this.Raw.IndicesValidateQueryForAll<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQueryForAll<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2421,30 +2421,30 @@ internal ElasticsearchResponse<T> IndicesValidateQueryDispatch<T>(ElasticsearchP
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> IndicesValidateQueryDispatchAsync<T>(ElasticsearchPathInfo<ValidateQueryRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> IndicesValidateQueryDispatchAsync<T>(ElasticsearchPathInfo<ValidateQueryRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_validate/query
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.IndicesValidateQueryGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQueryGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_validate/query
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.IndicesValidateQueryGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQueryGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_validate/query
-					return this.Raw.IndicesValidateQueryGetForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.IndicesValidateQueryGetForAllAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_validate/query
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesValidateQueryAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQueryAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_validate/query
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.IndicesValidateQueryAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQueryAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_validate/query
 					if (body != null)
-						return this.Raw.IndicesValidateQueryForAllAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.IndicesValidateQueryForAllAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2452,56 +2452,56 @@ internal Task<ElasticsearchResponse<T>> IndicesValidateQueryDispatchAsync<T>(Ela
 		}
 		
 		
-		internal ElasticsearchResponse<T> InfoDispatch<T>(ElasticsearchPathInfo<InfoRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> InfoDispatch<T>(ElasticsearchPathInfo<InfoRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /
-					return this.Raw.Info<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.Info<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.Info() into any of the following paths: \r\n - /");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> InfoDispatchAsync<T>(ElasticsearchPathInfo<InfoRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> InfoDispatchAsync<T>(ElasticsearchPathInfo<InfoRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /
-					return this.Raw.InfoAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.InfoAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.Info() into any of the following paths: \r\n - /");
 		}
 		
 		
-		internal ElasticsearchResponse<T> MgetDispatch<T>(ElasticsearchPathInfo<MultiGetRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MgetDispatch<T>(ElasticsearchPathInfo<MultiGetRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_mget
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.MgetGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MgetGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_mget
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.MgetGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MgetGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_mget
-					return this.Raw.MgetGet<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.MgetGet<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_mget
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.Mget<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mget<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_mget
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.Mget<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mget<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_mget
 					if (body != null)
-						return this.Raw.Mget<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mget<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2509,30 +2509,30 @@ internal ElasticsearchResponse<T> MgetDispatch<T>(ElasticsearchPathInfo<MultiGet
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MgetDispatchAsync<T>(ElasticsearchPathInfo<MultiGetRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MgetDispatchAsync<T>(ElasticsearchPathInfo<MultiGetRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_mget
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.MgetGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MgetGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_mget
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.MgetGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MgetGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_mget
-					return this.Raw.MgetGetAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.MgetGetAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_mget
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.MgetAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MgetAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_mget
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.MgetAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MgetAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_mget
 					if (body != null)
-						return this.Raw.MgetAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MgetAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2540,20 +2540,20 @@ internal Task<ElasticsearchResponse<T>> MgetDispatchAsync<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal ElasticsearchResponse<T> MltDispatch<T>(ElasticsearchPathInfo<MoreLikeThisRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MltDispatch<T>(ElasticsearchPathInfo<MoreLikeThisRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_mlt
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.MltGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MltGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_mlt
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.Mlt<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mlt<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2561,20 +2561,20 @@ internal ElasticsearchResponse<T> MltDispatch<T>(ElasticsearchPathInfo<MoreLikeT
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MltDispatchAsync<T>(ElasticsearchPathInfo<MoreLikeThisRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MltDispatchAsync<T>(ElasticsearchPathInfo<MoreLikeThisRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_mlt
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.MltGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MltGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_mlt
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.MltAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MltAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2582,30 +2582,30 @@ internal Task<ElasticsearchResponse<T>> MltDispatchAsync<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal ElasticsearchResponse<T> MpercolateDispatch<T>(ElasticsearchPathInfo<MpercolateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MpercolateDispatch<T>(ElasticsearchPathInfo<MpercolateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_mpercolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.MpercolateGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MpercolateGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_mpercolate
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.MpercolateGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MpercolateGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_mpercolate
-					return this.Raw.MpercolateGet<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.MpercolateGet<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_mpercolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.Mpercolate<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mpercolate<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_mpercolate
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.Mpercolate<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mpercolate<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_mpercolate
 					if (body != null)
-						return this.Raw.Mpercolate<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mpercolate<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2613,30 +2613,30 @@ internal ElasticsearchResponse<T> MpercolateDispatch<T>(ElasticsearchPathInfo<Mp
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MpercolateDispatchAsync<T>(ElasticsearchPathInfo<MpercolateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MpercolateDispatchAsync<T>(ElasticsearchPathInfo<MpercolateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_mpercolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.MpercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MpercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_mpercolate
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.MpercolateGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MpercolateGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_mpercolate
-					return this.Raw.MpercolateGetAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.MpercolateGetAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_mpercolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.MpercolateAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MpercolateAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_mpercolate
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.MpercolateAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MpercolateAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_mpercolate
 					if (body != null)
-						return this.Raw.MpercolateAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MpercolateAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2644,30 +2644,30 @@ internal Task<ElasticsearchResponse<T>> MpercolateDispatchAsync<T>(Elasticsearch
 		}
 		
 		
-		internal ElasticsearchResponse<T> MsearchDispatch<T>(ElasticsearchPathInfo<MultiSearchRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MsearchDispatch<T>(ElasticsearchPathInfo<MultiSearchRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_msearch
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.MsearchGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MsearchGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_msearch
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.MsearchGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MsearchGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_msearch
-					return this.Raw.MsearchGet<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.MsearchGet<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_msearch
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.Msearch<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Msearch<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_msearch
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.Msearch<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Msearch<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_msearch
 					if (body != null)
-						return this.Raw.Msearch<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Msearch<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2675,30 +2675,30 @@ internal ElasticsearchResponse<T> MsearchDispatch<T>(ElasticsearchPathInfo<Multi
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MsearchDispatchAsync<T>(ElasticsearchPathInfo<MultiSearchRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MsearchDispatchAsync<T>(ElasticsearchPathInfo<MultiSearchRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_msearch
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.MsearchGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MsearchGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_msearch
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.MsearchGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MsearchGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_msearch
-					return this.Raw.MsearchGetAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.MsearchGetAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_msearch
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.MsearchAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MsearchAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_msearch
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.MsearchAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MsearchAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_msearch
 					if (body != null)
-						return this.Raw.MsearchAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MsearchAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2706,30 +2706,30 @@ internal Task<ElasticsearchResponse<T>> MsearchDispatchAsync<T>(ElasticsearchPat
 		}
 		
 		
-		internal ElasticsearchResponse<T> MtermvectorsDispatch<T>(ElasticsearchPathInfo<MtermvectorsRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> MtermvectorsDispatch<T>(ElasticsearchPathInfo<MtermvectorsRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_mtermvectors
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.MtermvectorsGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MtermvectorsGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_mtermvectors
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.MtermvectorsGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MtermvectorsGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_mtermvectors
-					return this.Raw.MtermvectorsGet<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.MtermvectorsGet<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_mtermvectors
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.Mtermvectors<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mtermvectors<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_mtermvectors
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.Mtermvectors<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mtermvectors<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_mtermvectors
 					if (body != null)
-						return this.Raw.Mtermvectors<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Mtermvectors<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2737,30 +2737,30 @@ internal ElasticsearchResponse<T> MtermvectorsDispatch<T>(ElasticsearchPathInfo<
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> MtermvectorsDispatchAsync<T>(ElasticsearchPathInfo<MtermvectorsRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> MtermvectorsDispatchAsync<T>(ElasticsearchPathInfo<MtermvectorsRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_mtermvectors
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.MtermvectorsGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MtermvectorsGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_mtermvectors
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.MtermvectorsGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MtermvectorsGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_mtermvectors
-					return this.Raw.MtermvectorsGetAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.MtermvectorsGetAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_mtermvectors
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.MtermvectorsAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MtermvectorsAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_mtermvectors
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.MtermvectorsAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MtermvectorsAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_mtermvectors
 					if (body != null)
-						return this.Raw.MtermvectorsAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.MtermvectorsAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2768,190 +2768,190 @@ internal Task<ElasticsearchResponse<T>> MtermvectorsDispatchAsync<T>(Elasticsear
 		}
 		
 		
-		internal ElasticsearchResponse<T> NodesHotThreadsDispatch<T>(ElasticsearchPathInfo<NodesHotThreadsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> NodesHotThreadsDispatch<T>(ElasticsearchPathInfo<NodesHotThreadsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/nodes/{node_id}/hotthreads
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.NodesHotThreads<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesHotThreads<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_cluster/nodes/hotthreads
-					return this.Raw.NodesHotThreadsForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.NodesHotThreadsForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.NodesHotThreads() into any of the following paths: \r\n - /_cluster/nodes/hotthreads\r\n - /_cluster/nodes/hot_threads\r\n - /_cluster/nodes/{node_id}/hotthreads\r\n - /_cluster/nodes/{node_id}/hot_threads\r\n - /_nodes/hotthreads\r\n - /_nodes/hot_threads\r\n - /_nodes/{node_id}/hotthreads\r\n - /_nodes/{node_id}/hot_threads");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> NodesHotThreadsDispatchAsync<T>(ElasticsearchPathInfo<NodesHotThreadsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> NodesHotThreadsDispatchAsync<T>(ElasticsearchPathInfo<NodesHotThreadsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_cluster/nodes/{node_id}/hotthreads
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.NodesHotThreadsAsync<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesHotThreadsAsync<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_cluster/nodes/hotthreads
-					return this.Raw.NodesHotThreadsForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.NodesHotThreadsForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.NodesHotThreads() into any of the following paths: \r\n - /_cluster/nodes/hotthreads\r\n - /_cluster/nodes/hot_threads\r\n - /_cluster/nodes/{node_id}/hotthreads\r\n - /_cluster/nodes/{node_id}/hot_threads\r\n - /_nodes/hotthreads\r\n - /_nodes/hot_threads\r\n - /_nodes/{node_id}/hotthreads\r\n - /_nodes/{node_id}/hot_threads");
 		}
 		
 		
-		internal ElasticsearchResponse<T> NodesInfoDispatch<T>(ElasticsearchPathInfo<NodesInfoRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> NodesInfoDispatch<T>(ElasticsearchPathInfo<NodesInfoRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_nodes/{node_id}/{metric}
 					if (!pathInfo.NodeId.IsNullOrEmpty() && !pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.NodesInfo<T>(pathInfo.NodeId,pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesInfo<T>(pathInfo.NodeId,pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_nodes/{node_id}
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.NodesInfo<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesInfo<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_nodes/{metric}
 					if (!pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.NodesInfoForAll<T>(pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesInfoForAll<T>(pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_nodes
-					return this.Raw.NodesInfoForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.NodesInfoForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.NodesInfo() into any of the following paths: \r\n - /_nodes\r\n - /_nodes/{node_id}\r\n - /_nodes/{metric}\r\n - /_nodes/{node_id}/{metric}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> NodesInfoDispatchAsync<T>(ElasticsearchPathInfo<NodesInfoRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> NodesInfoDispatchAsync<T>(ElasticsearchPathInfo<NodesInfoRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_nodes/{node_id}/{metric}
 					if (!pathInfo.NodeId.IsNullOrEmpty() && !pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.NodesInfoAsync<T>(pathInfo.NodeId,pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesInfoAsync<T>(pathInfo.NodeId,pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_nodes/{node_id}
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.NodesInfoAsync<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesInfoAsync<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_nodes/{metric}
 					if (!pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.NodesInfoForAllAsync<T>(pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesInfoForAllAsync<T>(pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_nodes
-					return this.Raw.NodesInfoForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.NodesInfoForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.NodesInfo() into any of the following paths: \r\n - /_nodes\r\n - /_nodes/{node_id}\r\n - /_nodes/{metric}\r\n - /_nodes/{node_id}/{metric}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> NodesShutdownDispatch<T>(ElasticsearchPathInfo<NodesShutdownRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> NodesShutdownDispatch<T>(ElasticsearchPathInfo<NodesShutdownRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /_cluster/nodes/{node_id}/_shutdown
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.NodesShutdown<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesShutdown<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//POST /_shutdown
-					return this.Raw.NodesShutdownForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.NodesShutdownForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.NodesShutdown() into any of the following paths: \r\n - /_shutdown\r\n - /_cluster/nodes/_shutdown\r\n - /_cluster/nodes/{node_id}/_shutdown");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> NodesShutdownDispatchAsync<T>(ElasticsearchPathInfo<NodesShutdownRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> NodesShutdownDispatchAsync<T>(ElasticsearchPathInfo<NodesShutdownRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /_cluster/nodes/{node_id}/_shutdown
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.NodesShutdownAsync<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesShutdownAsync<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//POST /_shutdown
-					return this.Raw.NodesShutdownForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.NodesShutdownForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.NodesShutdown() into any of the following paths: \r\n - /_shutdown\r\n - /_cluster/nodes/_shutdown\r\n - /_cluster/nodes/{node_id}/_shutdown");
 		}
 		
 		
-		internal ElasticsearchResponse<T> NodesStatsDispatch<T>(ElasticsearchPathInfo<NodesStatsRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> NodesStatsDispatch<T>(ElasticsearchPathInfo<NodesStatsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_nodes/{node_id}/stats/{metric}/{index_metric}
 					if (!pathInfo.NodeId.IsNullOrEmpty() && !pathInfo.Metric.IsNullOrEmpty() && !pathInfo.IndexMetric.IsNullOrEmpty())
-						return this.Raw.NodesStats<T>(pathInfo.NodeId,pathInfo.Metric,pathInfo.IndexMetric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStats<T>(pathInfo.NodeId,pathInfo.Metric,pathInfo.IndexMetric,u => pathInfo.RequestParameters);
 					//GET /_nodes/{node_id}/stats/{metric}
 					if (!pathInfo.NodeId.IsNullOrEmpty() && !pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.NodesStats<T>(pathInfo.NodeId,pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStats<T>(pathInfo.NodeId,pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_nodes/stats/{metric}/{index_metric}
 					if (!pathInfo.Metric.IsNullOrEmpty() && !pathInfo.IndexMetric.IsNullOrEmpty())
-						return this.Raw.NodesStatsForAll<T>(pathInfo.Metric,pathInfo.IndexMetric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStatsForAll<T>(pathInfo.Metric,pathInfo.IndexMetric,u => pathInfo.RequestParameters);
 					//GET /_nodes/{node_id}/stats
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.NodesStats<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStats<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_nodes/stats/{metric}
 					if (!pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.NodesStatsForAll<T>(pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStatsForAll<T>(pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_nodes/stats
-					return this.Raw.NodesStatsForAll<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.NodesStatsForAll<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.NodesStats() into any of the following paths: \r\n - /_nodes/stats\r\n - /_nodes/{node_id}/stats\r\n - /_nodes/stats/{metric}\r\n - /_nodes/{node_id}/stats/{metric}\r\n - /_nodes/stats/{metric}/{index_metric}\r\n - /_nodes/{node_id}/stats/{metric}/{index_metric}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> NodesStatsDispatchAsync<T>(ElasticsearchPathInfo<NodesStatsRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> NodesStatsDispatchAsync<T>(ElasticsearchPathInfo<NodesStatsRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_nodes/{node_id}/stats/{metric}/{index_metric}
 					if (!pathInfo.NodeId.IsNullOrEmpty() && !pathInfo.Metric.IsNullOrEmpty() && !pathInfo.IndexMetric.IsNullOrEmpty())
-						return this.Raw.NodesStatsAsync<T>(pathInfo.NodeId,pathInfo.Metric,pathInfo.IndexMetric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStatsAsync<T>(pathInfo.NodeId,pathInfo.Metric,pathInfo.IndexMetric,u => pathInfo.RequestParameters);
 					//GET /_nodes/{node_id}/stats/{metric}
 					if (!pathInfo.NodeId.IsNullOrEmpty() && !pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.NodesStatsAsync<T>(pathInfo.NodeId,pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStatsAsync<T>(pathInfo.NodeId,pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_nodes/stats/{metric}/{index_metric}
 					if (!pathInfo.Metric.IsNullOrEmpty() && !pathInfo.IndexMetric.IsNullOrEmpty())
-						return this.Raw.NodesStatsForAllAsync<T>(pathInfo.Metric,pathInfo.IndexMetric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStatsForAllAsync<T>(pathInfo.Metric,pathInfo.IndexMetric,u => pathInfo.RequestParameters);
 					//GET /_nodes/{node_id}/stats
 					if (!pathInfo.NodeId.IsNullOrEmpty())
-						return this.Raw.NodesStatsAsync<T>(pathInfo.NodeId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStatsAsync<T>(pathInfo.NodeId,u => pathInfo.RequestParameters);
 					//GET /_nodes/stats/{metric}
 					if (!pathInfo.Metric.IsNullOrEmpty())
-						return this.Raw.NodesStatsForAllAsync<T>(pathInfo.Metric,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.NodesStatsForAllAsync<T>(pathInfo.Metric,u => pathInfo.RequestParameters);
 					//GET /_nodes/stats
-					return this.Raw.NodesStatsForAllAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.NodesStatsForAllAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.NodesStats() into any of the following paths: \r\n - /_nodes/stats\r\n - /_nodes/{node_id}/stats\r\n - /_nodes/stats/{metric}\r\n - /_nodes/{node_id}/stats/{metric}\r\n - /_nodes/stats/{metric}/{index_metric}\r\n - /_nodes/{node_id}/stats/{metric}/{index_metric}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> PercolateDispatch<T>(ElasticsearchPathInfo<PercolateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> PercolateDispatch<T>(ElasticsearchPathInfo<PercolateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_percolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.PercolateGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.PercolateGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					//GET /{index}/{type}/_percolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.PercolateGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.PercolateGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_percolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.Percolate<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Percolate<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					//POST /{index}/{type}/_percolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.Percolate<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Percolate<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2959,26 +2959,26 @@ internal ElasticsearchResponse<T> PercolateDispatch<T>(ElasticsearchPathInfo<Per
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> PercolateDispatchAsync<T>(ElasticsearchPathInfo<PercolateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> PercolateDispatchAsync<T>(ElasticsearchPathInfo<PercolateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_percolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.PercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.PercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					//GET /{index}/{type}/_percolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.PercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.PercolateGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_percolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.PercolateAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.PercolateAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					//POST /{index}/{type}/_percolate
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.PercolateAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.PercolateAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -2986,50 +2986,50 @@ internal Task<ElasticsearchResponse<T>> PercolateDispatchAsync<T>(ElasticsearchP
 		}
 		
 		
-		internal ElasticsearchResponse<T> PingDispatch<T>(ElasticsearchPathInfo<PingRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> PingDispatch<T>(ElasticsearchPathInfo<PingRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /
-					return this.Raw.Ping<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.Ping<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.Ping() into any of the following paths: \r\n - /");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> PingDispatchAsync<T>(ElasticsearchPathInfo<PingRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> PingDispatchAsync<T>(ElasticsearchPathInfo<PingRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.HEAD:
 					//HEAD /
-					return this.Raw.PingAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.PingAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.Ping() into any of the following paths: \r\n - /");
 		}
 		
 		
-		internal ElasticsearchResponse<T> ScrollDispatch<T>(ElasticsearchPathInfo<ScrollRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> ScrollDispatch<T>(ElasticsearchPathInfo<ScrollRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_search/scroll/{scroll_id}
 					if (!pathInfo.ScrollId.IsNullOrEmpty())
-						return this.Raw.ScrollGet<T>(pathInfo.ScrollId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ScrollGet<T>(pathInfo.ScrollId,u => pathInfo.RequestParameters);
 					//GET /_search/scroll
-					return this.Raw.ScrollGet<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ScrollGet<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /_search/scroll/{scroll_id}
 					if (!pathInfo.ScrollId.IsNullOrEmpty() && body != null)
-						return this.Raw.Scroll<T>(pathInfo.ScrollId,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Scroll<T>(pathInfo.ScrollId,body,u => pathInfo.RequestParameters);
 					//POST /_search/scroll
 					if (body != null)
-						return this.Raw.Scroll<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Scroll<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3037,24 +3037,24 @@ internal ElasticsearchResponse<T> ScrollDispatch<T>(ElasticsearchPathInfo<Scroll
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> ScrollDispatchAsync<T>(ElasticsearchPathInfo<ScrollRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> ScrollDispatchAsync<T>(ElasticsearchPathInfo<ScrollRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_search/scroll/{scroll_id}
 					if (!pathInfo.ScrollId.IsNullOrEmpty())
-						return this.Raw.ScrollGetAsync<T>(pathInfo.ScrollId,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ScrollGetAsync<T>(pathInfo.ScrollId,u => pathInfo.RequestParameters);
 					//GET /_search/scroll
-					return this.Raw.ScrollGetAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.ScrollGetAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /_search/scroll/{scroll_id}
 					if (!pathInfo.ScrollId.IsNullOrEmpty() && body != null)
-						return this.Raw.ScrollAsync<T>(pathInfo.ScrollId,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ScrollAsync<T>(pathInfo.ScrollId,body,u => pathInfo.RequestParameters);
 					//POST /_search/scroll
 					if (body != null)
-						return this.Raw.ScrollAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.ScrollAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3062,30 +3062,30 @@ internal Task<ElasticsearchResponse<T>> ScrollDispatchAsync<T>(ElasticsearchPath
 		}
 		
 		
-		internal ElasticsearchResponse<T> SearchDispatch<T>(ElasticsearchPathInfo<SearchRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SearchDispatch<T>(ElasticsearchPathInfo<SearchRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_search
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.SearchGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SearchGet<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_search
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.SearchGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SearchGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_search
-					return this.Raw.SearchGet<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.SearchGet<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_search
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.Search<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Search<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_search
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.Search<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Search<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_search
 					if (body != null)
-						return this.Raw.Search<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Search<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3093,30 +3093,30 @@ internal ElasticsearchResponse<T> SearchDispatch<T>(ElasticsearchPathInfo<Search
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SearchDispatchAsync<T>(ElasticsearchPathInfo<SearchRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SearchDispatchAsync<T>(ElasticsearchPathInfo<SearchRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/_search
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty())
-						return this.Raw.SearchGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SearchGetAsync<T>(pathInfo.Index,pathInfo.Type,u => pathInfo.RequestParameters);
 					//GET /{index}/_search
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.SearchGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SearchGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_search
-					return this.Raw.SearchGetAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.SearchGetAsync<T>(u => pathInfo.RequestParameters);
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/_search
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && body != null)
-						return this.Raw.SearchAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SearchAsync<T>(pathInfo.Index,pathInfo.Type,body,u => pathInfo.RequestParameters);
 					//POST /{index}/_search
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.SearchAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SearchAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_search
 					if (body != null)
-						return this.Raw.SearchAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SearchAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3124,20 +3124,20 @@ internal Task<ElasticsearchResponse<T>> SearchDispatchAsync<T>(ElasticsearchPath
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotCreateDispatch<T>(ElasticsearchPathInfo<SnapshotCreateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotCreateDispatch<T>(ElasticsearchPathInfo<SnapshotCreateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /_snapshot/{repository}/{snapshot}
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotCreate<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotCreate<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /_snapshot/{repository}/{snapshot}
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotCreatePost<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotCreatePost<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3145,20 +3145,20 @@ internal ElasticsearchResponse<T> SnapshotCreateDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotCreateDispatchAsync<T>(ElasticsearchPathInfo<SnapshotCreateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotCreateDispatchAsync<T>(ElasticsearchPathInfo<SnapshotCreateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /_snapshot/{repository}/{snapshot}
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotCreateAsync<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotCreateAsync<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /_snapshot/{repository}/{snapshot}
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotCreatePostAsync<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotCreatePostAsync<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3166,20 +3166,20 @@ internal Task<ElasticsearchResponse<T>> SnapshotCreateDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotCreateRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotCreateRepositoryRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotCreateRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotCreateRepositoryRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /_snapshot/{repository}
 					if (!pathInfo.Repository.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotCreateRepository<T>(pathInfo.Repository,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotCreateRepository<T>(pathInfo.Repository,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /_snapshot/{repository}
 					if (!pathInfo.Repository.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotCreateRepositoryPost<T>(pathInfo.Repository,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotCreateRepositoryPost<T>(pathInfo.Repository,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3187,20 +3187,20 @@ internal ElasticsearchResponse<T> SnapshotCreateRepositoryDispatch<T>(Elasticsea
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotCreateRepositoryRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotCreateRepositoryRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.PUT:
 					//PUT /_snapshot/{repository}
 					if (!pathInfo.Repository.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotCreateRepositoryAsync<T>(pathInfo.Repository,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotCreateRepositoryAsync<T>(pathInfo.Repository,body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /_snapshot/{repository}
 					if (!pathInfo.Repository.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotCreateRepositoryPostAsync<T>(pathInfo.Repository,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotCreateRepositoryPostAsync<T>(pathInfo.Repository,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3208,14 +3208,14 @@ internal Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryDispatchAsync<T>
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotDeleteDispatch<T>(ElasticsearchPathInfo<SnapshotDeleteRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotDeleteDispatch<T>(ElasticsearchPathInfo<SnapshotDeleteRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /_snapshot/{repository}/{snapshot}
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty())
-						return this.Raw.SnapshotDelete<T>(pathInfo.Repository,pathInfo.Snapshot,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotDelete<T>(pathInfo.Repository,pathInfo.Snapshot,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3223,14 +3223,14 @@ internal ElasticsearchResponse<T> SnapshotDeleteDispatch<T>(ElasticsearchPathInf
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotDeleteDispatchAsync<T>(ElasticsearchPathInfo<SnapshotDeleteRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotDeleteDispatchAsync<T>(ElasticsearchPathInfo<SnapshotDeleteRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /_snapshot/{repository}/{snapshot}
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty())
-						return this.Raw.SnapshotDeleteAsync<T>(pathInfo.Repository,pathInfo.Snapshot,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotDeleteAsync<T>(pathInfo.Repository,pathInfo.Snapshot,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3238,14 +3238,14 @@ internal Task<ElasticsearchResponse<T>> SnapshotDeleteDispatchAsync<T>(Elasticse
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotDeleteRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotDeleteRepositoryRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotDeleteRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotDeleteRepositoryRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /_snapshot/{repository}
 					if (!pathInfo.Repository.IsNullOrEmpty())
-						return this.Raw.SnapshotDeleteRepository<T>(pathInfo.Repository,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotDeleteRepository<T>(pathInfo.Repository,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3253,14 +3253,14 @@ internal ElasticsearchResponse<T> SnapshotDeleteRepositoryDispatch<T>(Elasticsea
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotDeleteRepositoryRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotDeleteRepositoryRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.DELETE:
 					//DELETE /_snapshot/{repository}
 					if (!pathInfo.Repository.IsNullOrEmpty())
-						return this.Raw.SnapshotDeleteRepositoryAsync<T>(pathInfo.Repository,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotDeleteRepositoryAsync<T>(pathInfo.Repository,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3268,14 +3268,14 @@ internal Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryDispatchAsync<T>
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotGetDispatch<T>(ElasticsearchPathInfo<SnapshotGetRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotGetDispatch<T>(ElasticsearchPathInfo<SnapshotGetRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_snapshot/{repository}/{snapshot}
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty())
-						return this.Raw.SnapshotGet<T>(pathInfo.Repository,pathInfo.Snapshot,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotGet<T>(pathInfo.Repository,pathInfo.Snapshot,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3283,14 +3283,14 @@ internal ElasticsearchResponse<T> SnapshotGetDispatch<T>(ElasticsearchPathInfo<S
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotGetDispatchAsync<T>(ElasticsearchPathInfo<SnapshotGetRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotGetDispatchAsync<T>(ElasticsearchPathInfo<SnapshotGetRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_snapshot/{repository}/{snapshot}
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty())
-						return this.Raw.SnapshotGetAsync<T>(pathInfo.Repository,pathInfo.Snapshot,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotGetAsync<T>(pathInfo.Repository,pathInfo.Snapshot,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3298,46 +3298,46 @@ internal Task<ElasticsearchResponse<T>> SnapshotGetDispatchAsync<T>(Elasticsearc
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotGetRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotGetRepositoryRequestParameters> pathInfo , object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotGetRepositoryDispatch<T>(ElasticsearchPathInfo<SnapshotGetRepositoryRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_snapshot/{repository}
 					if (!pathInfo.Repository.IsNullOrEmpty())
-						return this.Raw.SnapshotGetRepository<T>(pathInfo.Repository,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotGetRepository<T>(pathInfo.Repository,u => pathInfo.RequestParameters);
 					//GET /_snapshot
-					return this.Raw.SnapshotGetRepository<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.SnapshotGetRepository<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.SnapshotGetRepository() into any of the following paths: \r\n - /_snapshot\r\n - /_snapshot/{repository}");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotGetRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotGetRepositoryRequestParameters> pathInfo , object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotGetRepositoryDispatchAsync<T>(ElasticsearchPathInfo<SnapshotGetRepositoryRequestParameters> pathInfo )
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /_snapshot/{repository}
 					if (!pathInfo.Repository.IsNullOrEmpty())
-						return this.Raw.SnapshotGetRepositoryAsync<T>(pathInfo.Repository,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotGetRepositoryAsync<T>(pathInfo.Repository,u => pathInfo.RequestParameters);
 					//GET /_snapshot
-					return this.Raw.SnapshotGetRepositoryAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.SnapshotGetRepositoryAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.SnapshotGetRepository() into any of the following paths: \r\n - /_snapshot\r\n - /_snapshot/{repository}");
 		}
 		
 		
-		internal ElasticsearchResponse<T> SnapshotRestoreDispatch<T>(ElasticsearchPathInfo<SnapshotRestoreRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SnapshotRestoreDispatch<T>(ElasticsearchPathInfo<SnapshotRestoreRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /_snapshot/{repository}/{snapshot}/_restore
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotRestore<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotRestore<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3345,14 +3345,14 @@ internal ElasticsearchResponse<T> SnapshotRestoreDispatch<T>(ElasticsearchPathIn
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SnapshotRestoreDispatchAsync<T>(ElasticsearchPathInfo<SnapshotRestoreRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SnapshotRestoreDispatchAsync<T>(ElasticsearchPathInfo<SnapshotRestoreRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /_snapshot/{repository}/{snapshot}/_restore
 					if (!pathInfo.Repository.IsNullOrEmpty() && !pathInfo.Snapshot.IsNullOrEmpty() && body != null)
-						return this.Raw.SnapshotRestoreAsync<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SnapshotRestoreAsync<T>(pathInfo.Repository,pathInfo.Snapshot,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3360,70 +3360,70 @@ internal Task<ElasticsearchResponse<T>> SnapshotRestoreDispatchAsync<T>(Elastics
 		}
 		
 		
-		internal ElasticsearchResponse<T> SuggestDispatch<T>(ElasticsearchPathInfo<SuggestRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> SuggestDispatch<T>(ElasticsearchPathInfo<SuggestRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_suggest
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.Suggest<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Suggest<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_suggest
 					if (body != null)
-						return this.Raw.Suggest<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Suggest<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_suggest
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.SuggestGet<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SuggestGet<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_suggest
-					return this.Raw.SuggestGet<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.SuggestGet<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.Suggest() into any of the following paths: \r\n - /_suggest\r\n - /{index}/_suggest");
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> SuggestDispatchAsync<T>(ElasticsearchPathInfo<SuggestRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> SuggestDispatchAsync<T>(ElasticsearchPathInfo<SuggestRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/_suggest
 					if (!pathInfo.Index.IsNullOrEmpty() && body != null)
-						return this.Raw.SuggestAsync<T>(pathInfo.Index,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SuggestAsync<T>(pathInfo.Index,body,u => pathInfo.RequestParameters);
 					//POST /_suggest
 					if (body != null)
-						return this.Raw.SuggestAsync<T>(body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SuggestAsync<T>(body,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/_suggest
 					if (!pathInfo.Index.IsNullOrEmpty())
-						return this.Raw.SuggestGetAsync<T>(pathInfo.Index,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.SuggestGetAsync<T>(pathInfo.Index,u => pathInfo.RequestParameters);
 					//GET /_suggest
-					return this.Raw.SuggestGetAsync<T>(u => pathInfo.QueryString, deserializationState);
+					return this.Raw.SuggestGetAsync<T>(u => pathInfo.RequestParameters);
 
 			}
 			throw new DispatchException("Could not dispatch IElasticClient.Suggest() into any of the following paths: \r\n - /_suggest\r\n - /{index}/_suggest");
 		}
 		
 		
-		internal ElasticsearchResponse<T> TermvectorDispatch<T>(ElasticsearchPathInfo<TermvectorRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> TermvectorDispatch<T>(ElasticsearchPathInfo<TermvectorRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_termvector
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.TermvectorGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.TermvectorGet<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_termvector
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.Termvector<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Termvector<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3431,20 +3431,20 @@ internal ElasticsearchResponse<T> TermvectorDispatch<T>(ElasticsearchPathInfo<Te
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> TermvectorDispatchAsync<T>(ElasticsearchPathInfo<TermvectorRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> TermvectorDispatchAsync<T>(ElasticsearchPathInfo<TermvectorRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.GET:
 					//GET /{index}/{type}/{id}/_termvector
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty())
-						return this.Raw.TermvectorGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.TermvectorGetAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,u => pathInfo.RequestParameters);
 					break;
 
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_termvector
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.TermvectorAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.TermvectorAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3452,14 +3452,14 @@ internal Task<ElasticsearchResponse<T>> TermvectorDispatchAsync<T>(Elasticsearch
 		}
 		
 		
-		internal ElasticsearchResponse<T> UpdateDispatch<T>(ElasticsearchPathInfo<UpdateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal ElasticsearchResponse<T> UpdateDispatch<T>(ElasticsearchPathInfo<UpdateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_update
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.Update<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.Update<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					break;
 
 			}
@@ -3467,14 +3467,14 @@ internal ElasticsearchResponse<T> UpdateDispatch<T>(ElasticsearchPathInfo<Update
 		}
 		
 		
-		internal Task<ElasticsearchResponse<T>> UpdateDispatchAsync<T>(ElasticsearchPathInfo<UpdateRequestParameters> pathInfo , object body, object deserializationState = null)
+		internal Task<ElasticsearchResponse<T>> UpdateDispatchAsync<T>(ElasticsearchPathInfo<UpdateRequestParameters> pathInfo , object body)
 		{
 			switch(pathInfo.HttpMethod)
 			{
 				case PathInfoHttpMethod.POST:
 					//POST /{index}/{type}/{id}/_update
 					if (!pathInfo.Index.IsNullOrEmpty() && !pathInfo.Type.IsNullOrEmpty() && !pathInfo.Id.IsNullOrEmpty() && body != null)
-						return this.Raw.UpdateAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.QueryString, deserializationState);
+						return this.Raw.UpdateAsync<T>(pathInfo.Index,pathInfo.Type,pathInfo.Id,body,u => pathInfo.RequestParameters);
 					break;
 
 			}

From 61dfd065b6fe6da64003506750af66c1d9da110d Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Mon, 31 Mar 2014 15:02:19 +0200
Subject: [PATCH 07/20] renamed IConnectionConfigurationOverrides to
 IRequestConfiguration and super'ed connection overrides into
 IRequestConnectionConfiguration

---
 .../ElasticsearchHttpClient.cs                | 24 ++++++------
 .../ThriftConnection.cs                       | 24 ++++++------
 .../Connection/HttpConnection.cs              | 32 +++++++--------
 .../Connection/IConnection.cs                 | 39 ++++++++++++-------
 .../Connection/InMemoryConnection.cs          |  6 +--
 src/Elasticsearch.Net/Connection/Transport.cs | 33 +---------------
 .../Connection/TransportRequestState.cs       | 30 ++++++++++++++
 .../Domain/BaseRequestParameters.cs           | 28 +++++++++++++
 .../Domain/FluentRequestParameters.cs         | 34 +---------------
 .../Domain/IRequestParameters.cs              | 13 +++++++
 .../Elasticsearch.Net.csproj                  |  3 ++
 .../Connection/ConcurrencyTests.cs            |  2 +-
 .../Connection/SkipDeadNodesTests.cs          |  4 +-
 .../Connection/SniffingConnectionPoolTests.cs |  4 +-
 .../StaticConnectionPoolRetryTests.cs         |  8 ++--
 .../Stubs/NoopConnection.cs                   | 24 ++++++------
 16 files changed, 167 insertions(+), 141 deletions(-)
 create mode 100644 src/Elasticsearch.Net/Connection/TransportRequestState.cs
 create mode 100644 src/Elasticsearch.Net/Domain/BaseRequestParameters.cs
 create mode 100644 src/Elasticsearch.Net/Domain/IRequestParameters.cs

diff --git a/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs b/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs
index 7c2b03f6899..71b33ad87ac 100644
--- a/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs
+++ b/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs
@@ -54,62 +54,62 @@ public ElasticsearchResponse<Stream> DoSyncRequest<T>(string method, Uri uri, by
 
 
 
-		public Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public Task<ElasticsearchResponse<Stream>> Get(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public ElasticsearchResponse<Stream> GetSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public Task<ElasticsearchResponse<Stream>> Head(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public ElasticsearchResponse<Stream> HeadSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
 
-		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			throw new NotImplementedException();
 		}
diff --git a/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs b/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs
index cedecdbdf7d..c650d7a989f 100644
--- a/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs
+++ b/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs
@@ -45,7 +45,7 @@ public ThriftConnection(IConnectionConfigurationValues connectionSettings)
 
 		#region IConnection Members
 
-		public Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Get(Uri uri, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.GET;
@@ -59,7 +59,7 @@ public Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfiguration
 			});
 		}
 	
-		public Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Head(Uri uri, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.HEAD;
@@ -73,7 +73,7 @@ public Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfiguratio
 			});
 		}
 
-		public ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
+		public ElasticsearchResponse<Stream> GetSync(Uri uri, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.GET;
@@ -84,7 +84,7 @@ public ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOv
 			return this.Execute(restRequest, deserializationState);
 		}
 
-		public ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
+		public ElasticsearchResponse<Stream> HeadSync(Uri uri, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.HEAD;
@@ -95,7 +95,7 @@ public ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationO
 			return this.Execute(restRequest, deserializationState);
 		}
 
-		public Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.POST;
@@ -109,7 +109,7 @@ public Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectio
 				return this.Execute(restRequest, deserializationState);
 			});
 		}
-		public Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.PUT;
@@ -123,7 +123,7 @@ public Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnection
 				return this.Execute(restRequest, deserializationState);
 			});
 		}
-		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.DELETE;
@@ -138,7 +138,7 @@ public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnect
 			});
 		}
 
-		public ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
+		public ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.POST;
@@ -149,7 +149,7 @@ public ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionC
 			restRequest.Headers.Add("Content-Type", "application/json");
 			return this.Execute(restRequest, deserializationState);
 		}
-		public ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
+		public ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.PUT;
@@ -160,7 +160,7 @@ public ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionCo
 			restRequest.Headers.Add("Content-Type", "application/json");
 			return this.Execute(restRequest, deserializationState);
 		}
-		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
+		public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.DELETE;
@@ -174,7 +174,7 @@ public Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurat
 			});
 		}
 
-		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides deserializationState = null)
+		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.DELETE;
@@ -184,7 +184,7 @@ public ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfiguratio
 			restRequest.Headers.Add("Content-Type", "application/json");
 			return this.Execute(restRequest, deserializationState);
 		}
-		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides deserializationState = null)
+		public ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration deserializationState = null)
 		{
 			var restRequest = new RestRequest();
 			restRequest.Method = Method.DELETE;
diff --git a/src/Elasticsearch.Net/Connection/HttpConnection.cs b/src/Elasticsearch.Net/Connection/HttpConnection.cs
index d29b1c712d8..df6c4e54741 100644
--- a/src/Elasticsearch.Net/Connection/HttpConnection.cs
+++ b/src/Elasticsearch.Net/Connection/HttpConnection.cs
@@ -42,39 +42,39 @@ public HttpConnection(IConnectionConfigurationValues settings)
 			this._enableTrace = settings.TraceEnabled;
 		}
 
-		public virtual ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> GetSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			return this.HeaderOnlyRequest(uri, "GET", requestSpecificConfig);
 		}
-		public virtual ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> HeadSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			return this.HeaderOnlyRequest(uri, "HEAD", requestSpecificConfig);
 		}
 
-		public virtual ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			return this.BodyRequest(uri, data, "POST", requestSpecificConfig);
 		}
-		public virtual ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			return this.BodyRequest(uri, data, "PUT", requestSpecificConfig);
 		}
-		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			return this.HeaderOnlyRequest(uri, "DELETE", requestSpecificConfig);
 		}
-		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			return this.BodyRequest(uri, data, "DELETE", requestSpecificConfig);
 		}
 
-		private ElasticsearchResponse<Stream> HeaderOnlyRequest(Uri uri, string method, IConnectionConfigurationOverrides requestSpecificConfig)
+		private ElasticsearchResponse<Stream> HeaderOnlyRequest(Uri uri, string method, IRequestConnectionConfiguration requestSpecificConfig)
 		{
 			var r = this.CreateHttpWebRequest(uri, method);
 			return this.DoSynchronousRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
 
-		private ElasticsearchResponse<Stream> BodyRequest(Uri uri, byte[] data, string method, IConnectionConfigurationOverrides requestSpecificConfig)
+		private ElasticsearchResponse<Stream> BodyRequest(Uri uri, byte[] data, string method, IRequestConnectionConfiguration requestSpecificConfig)
 		{
 			var r = this.CreateHttpWebRequest(uri, method);
 			return this.DoSynchronousRequest(r, data, requestSpecificConfig);
@@ -107,34 +107,34 @@ public virtual IList<Uri> Sniff(Uri uri)
 			}
 		}
 
-		public virtual Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Get(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "GET");
 			return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
-		public virtual Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Head(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "HEAD");
 			return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
-		public virtual Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "POST");
 			return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig);
 		}
 
-		public virtual Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "PUT");
 			return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig);
 		}
 
-		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "DELETE");
 			return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig);
 		}
-		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "DELETE");
 			return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig);
@@ -205,7 +205,7 @@ protected virtual HttpWebRequest CreateWebRequest(Uri uri, string method)
 			return myReq;
 		}
 
-		protected virtual ElasticsearchResponse<Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		protected virtual ElasticsearchResponse<Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var path = request.RequestUri.ToString();
 			var method = request.Method;
@@ -253,7 +253,7 @@ private ElasticsearchResponse<Stream> WebToElasticsearchResponse(byte[] data, St
 			return cs;
 		}
 
-		protected virtual Task<ElasticsearchResponse<Stream>> DoAsyncRequest(HttpWebRequest request, byte[] data = null, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		protected virtual Task<ElasticsearchResponse<Stream>> DoAsyncRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var tcs = new TaskCompletionSource<ElasticsearchResponse<Stream>>();
 			if (this._ConnectionSettings.MaximumAsyncConnections <= 0
diff --git a/src/Elasticsearch.Net/Connection/IConnection.cs b/src/Elasticsearch.Net/Connection/IConnection.cs
index e5f3fcd3a24..5f9ec1567e8 100644
--- a/src/Elasticsearch.Net/Connection/IConnection.cs
+++ b/src/Elasticsearch.Net/Connection/IConnection.cs
@@ -7,32 +7,45 @@
 
 namespace Elasticsearch.Net.Connection
 {
-	public interface IConnectionConfigurationOverrides
+	public interface IRequestConnectionConfiguration
 	{
 		int RequestTimeout { get; }
 		int ConnectTimeout { get; }
 	}
 
+	public interface IRequestConfiguration : IRequestConnectionConfiguration
+	{
+		/// <summary>
+		/// This will override whatever is set on the connection configuration or whatever default the connectionpool has.
+		/// </summary>
+		int? MaxRetries { get; }
+
+		/// <summary>
+		/// This will force the operation on the specified node, this will bypass any configured connection pool and will no retry.
+		/// </summary>
+		Uri ForceNode { get; set; }
+	}
+
 	public interface IConnection
 	{
 
-		Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
-		ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		Task<ElasticsearchResponse<Stream>> Get(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> GetSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
-		ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		Task<ElasticsearchResponse<Stream>> Head(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> HeadSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
-		ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
-		ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
-		ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> DeleteSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null);
 
-		Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
-		ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null);
+		Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null);
+		ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null);
 
 		bool Ping(Uri uri);
 		IList<Uri> Sniff(Uri uri);
diff --git a/src/Elasticsearch.Net/Connection/InMemoryConnection.cs b/src/Elasticsearch.Net/Connection/InMemoryConnection.cs
index 59c51a9ad33..e734d021eab 100644
--- a/src/Elasticsearch.Net/Connection/InMemoryConnection.cs
+++ b/src/Elasticsearch.Net/Connection/InMemoryConnection.cs
@@ -23,12 +23,12 @@ public InMemoryConnection(IConnectionConfigurationValues settings, string fixedR
 			_fixedResultBytes = Encoding.UTF8.GetBytes(fixedResult);
 		}
 
-		protected override ElasticsearchResponse<Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		protected override ElasticsearchResponse<Stream> DoSynchronousRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			return this.ReturnConnectionStatus(request, data, requestSpecificConfig);
 		}
 
-		private ElasticsearchResponse<Stream> ReturnConnectionStatus(HttpWebRequest request, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		private ElasticsearchResponse<Stream> ReturnConnectionStatus(HttpWebRequest request, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var method = request.Method;
 			var path = request.RequestUri.ToString();
@@ -38,7 +38,7 @@ private ElasticsearchResponse<Stream> ReturnConnectionStatus(HttpWebRequest requ
 			return cs;
 		}
 
-		protected override Task<ElasticsearchResponse<Stream>> DoAsyncRequest(HttpWebRequest request, byte[] data = null, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		protected override Task<ElasticsearchResponse<Stream>> DoAsyncRequest(HttpWebRequest request, byte[] data = null, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			return Task.Factory.StartNew(() =>
 			{
diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index 0a3d6d70e47..8cd000a60c7 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -16,35 +16,6 @@
 
 namespace Elasticsearch.Net.Connection
 {
-
-	class TransportRequestState<T>
-	{
-		public string Method { get; private set; }
-		public string Path { get; private set; }
-		public byte[] PostData { get; private set; }
-		public ElasticsearchResponseTracer<T> Tracer { get; private set; }
-
-		public int? Seed { get; set; }
-
-		public IConnectionConfigurationOverrides RequestConfiguration { get; set; }
-		public object DeserializationState { get; private set; }
-
-		public TransportRequestState(ElasticsearchResponseTracer<T> tracer, string method, string path, byte[] postData = null, IRequestParameters requestParameters = null)
-		{
-			this.Method = method;
-			this.Path = path;
-			this.PostData = postData;
-			if (requestParameters != null)
-			{
-				if (requestParameters.QueryString != null) this.Path += requestParameters.QueryString.ToQueryString();
-				this.DeserializationState = requestParameters.DeserializationState;
-				this.RequestConfiguration = requestParameters.RequestConfiguration;
-			}
-			this.Tracer = tracer;
-		}
-
-	}
-
 	public class Transport : ITransport
 	{
 		protected static readonly string MaxRetryExceptionMessage = "Unable to perform request: '{0} {1}' on any of the nodes after retrying {2} times.";
@@ -171,7 +142,7 @@ private ElasticsearchResponse<T> RetryRequest<T>(TransportRequestState<T> reques
 			return this.DoRequest<T>(requestState, ++retried);
 		}
 
-		private ElasticsearchResponse<Stream> _doRequest(string method, Uri uri, byte[] postData, IConnectionConfigurationOverrides requestSpecificConfig)
+		private ElasticsearchResponse<Stream> _doRequest(string method, Uri uri, byte[] postData, IRequestConfiguration requestSpecificConfig)
 		{
 			switch (method.ToLowerInvariant())
 			{
@@ -261,7 +232,7 @@ private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(TransportRequestStat
 			throw new MaxRetryException(exceptionMessage, e);
 		}
 
-		private Task<ElasticsearchResponse<Stream>> _doRequestAsync(string method, Uri uri, byte[] postData, IConnectionConfigurationOverrides requestSpecificConfig)
+		private Task<ElasticsearchResponse<Stream>> _doRequestAsync(string method, Uri uri, byte[] postData, IRequestConfiguration requestSpecificConfig)
 		{
 			switch (method.ToLowerInvariant())
 			{
diff --git a/src/Elasticsearch.Net/Connection/TransportRequestState.cs b/src/Elasticsearch.Net/Connection/TransportRequestState.cs
new file mode 100644
index 00000000000..db0df90d44d
--- /dev/null
+++ b/src/Elasticsearch.Net/Connection/TransportRequestState.cs
@@ -0,0 +1,30 @@
+namespace Elasticsearch.Net.Connection
+{
+	class TransportRequestState<T>
+	{
+		public string Method { get; private set; }
+		public string Path { get; private set; }
+		public byte[] PostData { get; private set; }
+		public ElasticsearchResponseTracer<T> Tracer { get; private set; }
+
+		public int? Seed { get; set; }
+
+		public IRequestConfiguration RequestConfiguration { get; set; }
+		public object DeserializationState { get; private set; }
+
+		public TransportRequestState(ElasticsearchResponseTracer<T> tracer, string method, string path, byte[] postData = null, IRequestParameters requestParameters = null)
+		{
+			this.Method = method;
+			this.Path = path;
+			this.PostData = postData;
+			if (requestParameters != null)
+			{
+				if (requestParameters.QueryString != null) this.Path += requestParameters.QueryString.ToQueryString();
+				this.DeserializationState = requestParameters.DeserializationState;
+				this.RequestConfiguration = requestParameters.RequestConfiguration;
+			}
+			this.Tracer = tracer;
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/Domain/BaseRequestParameters.cs b/src/Elasticsearch.Net/Domain/BaseRequestParameters.cs
new file mode 100644
index 00000000000..a64384db6a2
--- /dev/null
+++ b/src/Elasticsearch.Net/Domain/BaseRequestParameters.cs
@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Collections.Specialized;
+using Elasticsearch.Net.Connection;
+
+namespace Elasticsearch.Net
+{
+	public abstract class BaseRequestParameters : IRequestParameters
+	{
+		internal readonly IDictionary<string, object> _QueryStringDictionary = new Dictionary<string, object>();
+		
+		internal object _DeserializationState = null;
+
+		internal IRequestConfiguration _RequestConfiguration = null;
+		internal NameValueCollection _queryString;
+
+		NameValueCollection IRequestParameters.QueryString { get { return _queryString;}  }
+
+		object IRequestParameters.DeserializationState
+		{
+			get { return _DeserializationState; }
+		}
+
+		IRequestConfiguration IRequestParameters.RequestConfiguration
+		{
+			get { return _RequestConfiguration; }
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
index ef7ea9f5483..6515e6aed7d 100644
--- a/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
+++ b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
@@ -1,43 +1,11 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.Specialized;
 using System.Linq;
 using System.Text;
 using Elasticsearch.Net.Connection;
 
 namespace Elasticsearch.Net
 {
-	
-	public interface IRequestParameters
-	{
-		NameValueCollection QueryString { get; }
-		object DeserializationState { get; }
-		IConnectionConfigurationOverrides RequestConfiguration { get; }
-
-	}
-
-	public abstract class BaseRequestParameters : IRequestParameters
-	{
-		internal readonly IDictionary<string, object> _QueryStringDictionary = new Dictionary<string, object>();
-		
-		internal object _DeserializationState = null;
-
-		internal IConnectionConfigurationOverrides _RequestConfiguration = null;
-		internal NameValueCollection _queryString;
-
-		NameValueCollection IRequestParameters.QueryString { get { return _queryString;}  }
-
-		object IRequestParameters.DeserializationState
-		{
-			get { return _DeserializationState; }
-		}
-
-		IConnectionConfigurationOverrides IRequestParameters.RequestConfiguration
-		{
-			get { return _RequestConfiguration; }
-		}
-	}
-
 	/// <summary>
 	/// Used by the raw client to compose querystring parameters in a matter that still exposes some xmldocs
 	/// You can always pass a simple NameValueCollection if you want.
@@ -53,7 +21,7 @@ public T Add(string name, object value)
 			return (T)this;
 		}
 
-		public T RequestConfiguration(IConnectionConfigurationOverrides requestConfiguration)
+		public T RequestConfiguration(IRequestConfiguration requestConfiguration)
 		{
 			this._RequestConfiguration = requestConfiguration;
 			return (T)this;
diff --git a/src/Elasticsearch.Net/Domain/IRequestParameters.cs b/src/Elasticsearch.Net/Domain/IRequestParameters.cs
new file mode 100644
index 00000000000..a1dd5446f07
--- /dev/null
+++ b/src/Elasticsearch.Net/Domain/IRequestParameters.cs
@@ -0,0 +1,13 @@
+using System.Collections.Specialized;
+using Elasticsearch.Net.Connection;
+
+namespace Elasticsearch.Net
+{
+	public interface IRequestParameters
+	{
+		NameValueCollection QueryString { get; }
+		object DeserializationState { get; }
+		IRequestConfiguration RequestConfiguration { get; }
+
+	}
+}
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/Elasticsearch.Net.csproj b/src/Elasticsearch.Net/Elasticsearch.Net.csproj
index 135e6948157..ccd4f17dbcd 100644
--- a/src/Elasticsearch.Net/Elasticsearch.Net.csproj
+++ b/src/Elasticsearch.Net/Elasticsearch.Net.csproj
@@ -45,7 +45,10 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Connection\TransportRequestState.cs" />
+    <Compile Include="Domain\BaseRequestParameters.cs" />
     <Compile Include="Domain\IHideObjectMembers.cs" />
+    <Compile Include="Domain\IRequestParameters.cs" />
     <Compile Include="Domain\VoidResponse.cs" />
     <Compile Include="Providers\DateTimeProvider.cs" />
     <Compile Include="Connection\HttpConnection.cs" />
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs
index 93cb262cf96..ff3ab5080c9 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs
@@ -140,7 +140,7 @@ public override IList<Uri> Sniff(Uri uri)
 				return  _rnd.Next(1, 11) % 3 == 0 ? _uris : _uris2;
 			}
 
-			public override ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestConfigurationOverrides = null)
+			public override ElasticsearchResponse<Stream> GetSync(Uri uri, IRequestConnectionConfiguration requestConfigurationOverrides = null)
 			{
 				var statusCode = _rnd.Next(1, 9) % 3 == 0 ? 503 : 200;
 				if (uri.Port == 9202)
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs
index ecc9270f3b3..f6bfc613cf5 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs
@@ -49,7 +49,7 @@ public void DeadNodesAreNotVisited_AndPingedAppropiately()
 				);
 				
 				var seenNodes = new List<Uri>();
-				getCall.Invokes((Uri u, IConnectionConfigurationOverrides o) => seenNodes.Add(u));
+				getCall.Invokes((Uri u, IRequestConfiguration o) => seenNodes.Add(u));
 
 				var pingCall = FakeCalls.Ping(fake);
 				pingCall.Returns(true);
@@ -100,7 +100,7 @@ public async void DeadNodesAreNotVisited_AndPingedAppropiately_Async()
 				);
 				
 				var seenNodes = new List<Uri>();
-				getCall.Invokes((Uri u, IConnectionConfigurationOverrides o) => seenNodes.Add(u));
+				getCall.Invokes((Uri u, IRequestConfiguration o) => seenNodes.Add(u));
 
 				var pingCall = FakeCalls.Ping(fake);
 				pingCall.Returns(true);
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
index 7863339eded..056cbd637ea 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
@@ -201,7 +201,7 @@ public void HostsReturnedBySniffAreVisited()
 
 				var seenNodes = new List<Uri>();
 				//var getCall =  FakeResponse.GetSyncCall(fake);
-				var getCall = A.CallTo(() => connection.GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
+				var getCall = A.CallTo(() => connection.GetSync(A<Uri>._, A<IRequestConfiguration>._));
 				getCall.ReturnsNextFromSequence(
 					FakeResponse.Ok(config), //info 1
 					FakeResponse.Bad(config), //info 2
@@ -214,7 +214,7 @@ public void HostsReturnedBySniffAreVisited()
 					FakeResponse.Ok(config), //info 8
 					FakeResponse.Ok(config) //info 9
 				);
-				getCall.Invokes((Uri u, IConnectionConfigurationOverrides o) => seenNodes.Add(u));
+				getCall.Invokes((Uri u, IRequestConfiguration o) => seenNodes.Add(u));
 
 				fake.Provide<ITransport>(fake.Resolve<Transport>());
 				var client1 = fake.Resolve<ElasticsearchClient>();
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs
index fd342a94ea1..31c56e1d145 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs
@@ -127,7 +127,7 @@ public void HardRetryLimitTakesPrecedenceOverNumberOfNodes()
 						.MaximumRetries(7)
 				);
 				var getCall = A.CallTo(() => 
-					fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
+					fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IRequestConfiguration>._));
 				getCall.Throws<Exception>();
 				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
 				pingCall.Returns(true);
@@ -158,7 +158,7 @@ public void AConnectionMustBeMadeEvenIfAllNodesAreDead()
 						.MaximumRetries(4)
 				);
 				//set up our GET to / to return 4 503's followed by a 200
-				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
+				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IRequestConfiguration>._));
 				getCall.ReturnsNextFromSequence(
 					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
 					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
@@ -215,7 +215,7 @@ public void AllNodesWillBeMarkedDead()
 					call.Returns(DateTime.UtcNow.AddSeconds(60));
 				
 				//When we do a GET on / we always recieve a 503
-				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
+				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IRequestConfiguration>._));
 				getCall.Returns(
 					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null)
 				);
@@ -262,7 +262,7 @@ public void IfAConnectionComesBackToLifeOnItsOwnItShouldBeMarked()
 
 				//fake getsync handler that return a 503 4 times and then a 200
 				//this will cause all 4 nodes to be marked dead on the first client call
-				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IConnectionConfigurationOverrides>._));
+				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IRequestConfiguration>._));
 				getCall.ReturnsNextFromSequence(
 					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
 					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs
index e13a6596012..d14aa001283 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs
@@ -48,72 +48,72 @@ IConnectionConfigurationValues configValues
 		}
 
 
-		public virtual Task<ElasticsearchResponse<Stream>> Get(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Get(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			return DoAsyncRequest(uri);
 		}
 
-		public virtual ElasticsearchResponse<Stream> GetSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null) 
+		public virtual ElasticsearchResponse<Stream> GetSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null) 
 		{
 			_uriObserver.Observe(uri);
 			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<Stream>> Head(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Head(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<Stream> HeadSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> HeadSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> PostSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> PutSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return _responseGenerator.Create();
 		}
 
-		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return Task.FromResult(_responseGenerator.Create());
 		}
 
-		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IConnectionConfigurationOverrides requestSpecificConfig = null)
+		public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			_uriObserver.Observe(uri);
 			return _responseGenerator.Create();

From 833c415f595a316377e7b9b109de1ec2911ce06d Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 10:14:06 +0200
Subject: [PATCH 08/20] fixed failing unit tests after shuffling
 responsibilities around

---
 .../ElasticsearchHttpClient.cs                |   9 -
 .../ThriftConnection.cs                       |  23 --
 .../Connection/HttpConnection.cs              |  28 +-
 .../Connection/IConnection.cs                 |  22 --
 .../Connection/IRequestConfiguration.cs       |  62 ++++
 .../IRequestConnectionConfiguration.cs        |  46 +++
 .../Connection/ITransport.cs                  |   8 +-
 src/Elasticsearch.Net/Connection/Transport.cs | 159 ++++++++--
 .../ConnectionPool/IConnectionPool.cs         |  28 +-
 .../SingleNodeConnectionPool.cs               |  14 +-
 .../ConnectionPool/SniffingConnectionPool.cs  |  23 +-
 .../ConnectionPool/StaticConnectionPool.cs    |  19 +-
 .../Domain/ElasticsearchResponse.cs           |   8 +-
 .../Elasticsearch.Net.csproj                  |   5 +-
 src/Elasticsearch.Net/ElasticsearchClient.cs  |   3 +-
 ...NodesException.cs => MaxRetryException.cs} |   6 +
 .../Extensions/TaskExtensions.cs              | 294 ++++++++++++++++++
 .../Connection/ConcurrencyTests.cs            |  10 +-
 .../Connection/RetryTests.cs                  |  12 +-
 .../Connection/SkipDeadNodesTests.cs          |  16 +-
 .../Connection/SniffingConnectionPoolTests.cs |  71 +++--
 .../StaticConnectionPoolRetryTests.cs         |  76 ++---
 .../Stubs/FakeCalls.cs                        |  80 ++++-
 .../Stubs/FakeResponse.cs                     |   5 +-
 .../Stubs/NoopConnection.cs                   |  10 -
 25 files changed, 771 insertions(+), 266 deletions(-)
 create mode 100644 src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
 create mode 100644 src/Elasticsearch.Net/Connection/IRequestConnectionConfiguration.cs
 rename src/Elasticsearch.Net/Exceptions/{OutOfNodesException.cs => MaxRetryException.cs} (78%)
 create mode 100644 src/Elasticsearch.Net/Extensions/TaskExtensions.cs

diff --git a/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs b/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs
index 71b33ad87ac..205e7e8af67 100644
--- a/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs
+++ b/src/Connections/Elasticsearch.Net.Connection.HttpClient/ElasticsearchHttpClient.cs
@@ -114,14 +114,5 @@ public ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IRequestCo
 			throw new NotImplementedException();
 		}
 
-		public bool Ping(Uri uri)
-		{
-			throw new NotImplementedException();
-		}
-
-		public IList<Uri> Sniff(Uri uri)
-		{
-			throw new NotImplementedException();
-		}
 	}
 }
diff --git a/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs b/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs
index c650d7a989f..08fc96415b2 100644
--- a/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs
+++ b/src/Connections/Elasticsearch.Net.Connection.Thrift/ThriftConnection.cs
@@ -196,29 +196,6 @@ public ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IRequestCo
 			return this.Execute(restRequest, deserializationState);
 		}
 
-		public bool Ping(Uri uri)
-		{
-			var restRequest = new RestRequest();
-			restRequest.Method = Method.HEAD;
-			restRequest.Uri = uri;
-			
-			restRequest.Headers = new Dictionary<string, string>();
-			restRequest.Headers.Add("Content-Type", "application/json");
-			var r  = this.Execute(restRequest, null); //TODO VoidResponse
-			return r.Success;
-		}
-
-		public IList<Uri> Sniff(Uri uri)
-		{
-			var restRequest = new RestRequest();
-			restRequest.Method = Method.GET;
-			restRequest.Uri = new Uri(uri,"/_nodes/_all/clear?timeout=" + this._connectionSettings.PingTimeout.GetValueOrDefault(50));
-
-			restRequest.Headers = new Dictionary<string, string>();
-			restRequest.Headers.Add("Content-Type", "application/json");
-			var r  = this.Execute(restRequest, null);
-			return Sniffer.FromStream(r, r.Response, this._connectionSettings.Serializer);
-		}
 
 		#endregion
 
diff --git a/src/Elasticsearch.Net/Connection/HttpConnection.cs b/src/Elasticsearch.Net/Connection/HttpConnection.cs
index df6c4e54741..b920fded6b8 100644
--- a/src/Elasticsearch.Net/Connection/HttpConnection.cs
+++ b/src/Elasticsearch.Net/Connection/HttpConnection.cs
@@ -68,6 +68,7 @@ public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IR
 			return this.BodyRequest(uri, data, "DELETE", requestSpecificConfig);
 		}
 
+
 		private ElasticsearchResponse<Stream> HeaderOnlyRequest(Uri uri, string method, IRequestConnectionConfiguration requestSpecificConfig)
 		{
 			var r = this.CreateHttpWebRequest(uri, method);
@@ -80,33 +81,6 @@ private ElasticsearchResponse<Stream> BodyRequest(Uri uri, byte[] data, string m
 			return this.DoSynchronousRequest(r, data, requestSpecificConfig);
 		}
 
-		public virtual bool Ping(Uri uri)
-		{
-			var request = this.CreateHttpWebRequest(uri, "HEAD");
-			request.Timeout = this._ConnectionSettings.PingTimeout.GetValueOrDefault(50);
-			request.ReadWriteTimeout = this._ConnectionSettings.PingTimeout.GetValueOrDefault(50);
-			using (var response = (HttpWebResponse)request.GetResponse())
-			{
-				return response.StatusCode == HttpStatusCode.OK;
-			}
-		}
-
-		public virtual IList<Uri> Sniff(Uri uri)
-		{
-			uri = new Uri(uri, "_nodes/_all/clear?timeout=" + this._ConnectionSettings.PingTimeout.GetValueOrDefault(50));
-			var request = this.CreateHttpWebRequest(uri, "GET");
-			request.Timeout = this._ConnectionSettings.Timeout;
-			request.ReadWriteTimeout = this._ConnectionSettings.Timeout;
-			using (var response = (HttpWebResponse)request.GetResponse())
-			using (var responseStream = response.GetResponseStream())
-			{
-				if (response.StatusCode != HttpStatusCode.OK)
-					return new List<Uri>();
-				var cs = ElasticsearchResponse<object>.Create(this._ConnectionSettings, (int)response.StatusCode, "GET", uri.AbsolutePath, null);
-				return Sniffer.FromStream(cs, responseStream, this._ConnectionSettings.Serializer);
-			}
-		}
-
 		public virtual Task<ElasticsearchResponse<Stream>> Get(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
 			var r = this.CreateHttpWebRequest(uri, "GET");
diff --git a/src/Elasticsearch.Net/Connection/IConnection.cs b/src/Elasticsearch.Net/Connection/IConnection.cs
index 5f9ec1567e8..7c0380aa155 100644
--- a/src/Elasticsearch.Net/Connection/IConnection.cs
+++ b/src/Elasticsearch.Net/Connection/IConnection.cs
@@ -7,25 +7,6 @@
 
 namespace Elasticsearch.Net.Connection
 {
-	public interface IRequestConnectionConfiguration
-	{
-		int RequestTimeout { get; }
-		int ConnectTimeout { get; }
-	}
-
-	public interface IRequestConfiguration : IRequestConnectionConfiguration
-	{
-		/// <summary>
-		/// This will override whatever is set on the connection configuration or whatever default the connectionpool has.
-		/// </summary>
-		int? MaxRetries { get; }
-
-		/// <summary>
-		/// This will force the operation on the specified node, this will bypass any configured connection pool and will no retry.
-		/// </summary>
-		Uri ForceNode { get; set; }
-	}
-
 	public interface IConnection
 	{
 
@@ -47,8 +28,5 @@ public interface IConnection
 		Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null);
 		ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null);
 
-		bool Ping(Uri uri);
-		IList<Uri> Sniff(Uri uri);
-
 	}
 }
diff --git a/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs b/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
new file mode 100644
index 00000000000..82247dfd404
--- /dev/null
+++ b/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
@@ -0,0 +1,62 @@
+using System;
+using System.ComponentModel;
+
+namespace Elasticsearch.Net.Connection
+{
+	public interface IRequestConfiguration : IRequestConnectionConfiguration
+	{
+		/// <summary>
+		/// This will override whatever is set on the connection configuration or whatever default the connectionpool has.
+		/// </summary>
+		int? MaxRetries { get; }
+
+		/// <summary>
+		/// This will force the operation on the specified node, this will bypass any configured connection pool and will no retry.
+		/// </summary>
+		Uri ForceNode { get; }
+
+		/// <summary>
+		/// Forces no sniffing to occur on the request no matter what configuration is in place 
+		/// globally
+		/// </summary>
+		bool? SniffingDisabled { get; }
+
+	}
+
+	public class RequestConfiguration : RequestConfiguration<RequestConfiguration>, IRequestConfiguration
+	{
+		
+	}
+
+	[Browsable(false)]
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public class RequestConfiguration<T> : RequestConnectionConfiguration<T>, IRequestConfiguration
+		where T : RequestConfiguration<T>, IRequestConfiguration
+	{
+		private int? _maxRetries;
+		private Uri _forceNode;
+		private bool? _sniffingDisabled;
+
+		int? IRequestConfiguration.MaxRetries
+		{
+			get { return _maxRetries; }
+		}
+
+		Uri IRequestConfiguration.ForceNode
+		{
+			get { return _forceNode; }
+		}
+
+		bool? IRequestConfiguration.SniffingDisabled
+		{
+			get { return _sniffingDisabled; }
+		}
+
+		public T DisableSniffing(bool? disable = true)
+		{
+			this._sniffingDisabled = disable;
+			return (T)this;
+
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/Connection/IRequestConnectionConfiguration.cs b/src/Elasticsearch.Net/Connection/IRequestConnectionConfiguration.cs
new file mode 100644
index 00000000000..bb2e57374cf
--- /dev/null
+++ b/src/Elasticsearch.Net/Connection/IRequestConnectionConfiguration.cs
@@ -0,0 +1,46 @@
+using System.ComponentModel;
+
+namespace Elasticsearch.Net.Connection
+{
+	public interface IRequestConnectionConfiguration
+	{
+		int? TimeoutRequest { get; }
+		int? TimeoutConnect { get; }
+	}
+	
+
+	public class RequestConnectionConfiguration : RequestConnectionConfiguration<RequestConnectionConfiguration>, IRequestConnectionConfiguration
+	{
+
+	}
+	
+	[Browsable(false)]
+	[EditorBrowsable(EditorBrowsableState.Never)]
+	public class RequestConnectionConfiguration<T> : IRequestConnectionConfiguration
+		where T : RequestConnectionConfiguration<T>, IRequestConnectionConfiguration
+	{
+		private int? _timeoutRequest;
+		int? IRequestConnectionConfiguration.TimeoutRequest
+		{
+			get { return _timeoutRequest; }
+		}
+
+		private int? _timeoutConnection;
+		int? IRequestConnectionConfiguration.TimeoutConnect
+		{
+			get { return _timeoutConnection; }
+		}
+
+		public T RequestTimeout(int request)
+		{
+			this._timeoutRequest = request;
+			return (T)this;
+		}
+		public T ConnectTimeout(int request)
+		{
+			this._timeoutConnection = request;
+			return (T)this;
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/Connection/ITransport.cs b/src/Elasticsearch.Net/Connection/ITransport.cs
index 65c1a93c88e..79930922a22 100644
--- a/src/Elasticsearch.Net/Connection/ITransport.cs
+++ b/src/Elasticsearch.Net/Connection/ITransport.cs
@@ -1,3 +1,6 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Threading.Tasks;
 using Elasticsearch.Net.Serialization;
@@ -15,7 +18,10 @@ ElasticsearchResponse<T> DoRequest<T>(
 			object data = null, 
 			IRequestParameters requestParameters = null);
 
-		void Sniff(bool fromStartup = false);
+		IList<Uri> Sniff();
+		void SniffClusterState();
+		bool Ping(Uri baseUri);
+		Task<bool> PingAsync(Uri baseUri);
 
 		Task<ElasticsearchResponse<T>> DoRequestAsync<T>(
 			string method, 
diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index 8cd000a60c7..b605fc8c39b 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -45,12 +45,81 @@ public Transport(
 			this._dateTimeProvider = dateTimeProvider ?? new DateTimeProvider();
 
 			this._lastSniff = this._dateTimeProvider.Now();
+
+			this.Settings.Serializer = this._serializer;
+			if (this._connectionPool.AcceptsUpdates && this.Settings.SniffsOnStartup)
+				this.Sniff();
+		}
+
+
+		public virtual bool Ping(Uri baseUri)
+		{
+			var pingTimeout = this.Settings.PingTimeout.GetValueOrDefault(50);
+			var requestOverrides = new RequestConnectionConfiguration()
+				.ConnectTimeout(pingTimeout)
+				.RequestTimeout(pingTimeout);
+			var response = this._connection.HeadSync(CreateUriToPath(baseUri, ""), requestOverrides);
+			if (response.Response == null) return false;
+			using(response.Response)
+				return response.Success;
+		}
+		
+		public virtual Task<bool> PingAsync(Uri baseUri)
+		{
+			var pingTimeout = this.Settings.PingTimeout.GetValueOrDefault(50);
+			var requestOverrides = new RequestConnectionConfiguration()
+				.ConnectTimeout(pingTimeout)
+				.RequestTimeout(pingTimeout);
+
+			return this._connection.Head(CreateUriToPath(baseUri, ""), requestOverrides)
+				.ContinueWith(t=>
+				{
+					var response = t.Result;
+					if (response.Response == null) return false;
+
+					using(response.Response)
+						return response.Success;
+				});
 		}
 
-		public void Sniff(bool fromStartup = false)
+		public IList<Uri> Sniff()
 		{
-			this._connectionPool.Sniff(this._connection, fromStartup);
+			var pingTimeout = this.Settings.PingTimeout.GetValueOrDefault(50);
+			var requestOverrides = new RequestConfiguration()
+				.ConnectTimeout(pingTimeout)
+				.RequestTimeout(pingTimeout)
+				.DisableSniffing();
+			var requestParameters = new FluentRequestParameters()
+				.RequestConfiguration(requestOverrides);
+			
+			var path = "_nodes/_all/clear?timeout=" + pingTimeout;
+
+			using (var tracer = new ElasticsearchResponseTracer<Stream>(this.Settings.TraceEnabled))
+			{
+				var requestState = new TransportRequestState<Stream>(tracer, "GET", path, requestParameters: requestParameters);
+				var response = this.DoRequest(requestState);
+				if (response.Response == null) return null;
+
+				using (response.Response)
+				{
+					return Sniffer.FromStream(response, response.Response, this.Serializer);
+					
+				}
+			}
+		}
+		
+		public virtual void SniffClusterState()
+		{
+			if (!this._connectionPool.AcceptsUpdates)
+				return;
+
+			var newClusterState = this.Sniff();
+			if (!newClusterState.HasAny())
+				return;
+
+			this._connectionPool.UpdateNodeList(newClusterState);
 			this._lastSniff = this._dateTimeProvider.Now();
+		
 		}
 
 		private void SniffIfInformationIsTooOld(int retried)
@@ -59,7 +128,7 @@ private void SniffIfInformationIsTooOld(int retried)
 			var now = this._dateTimeProvider.Now();
 			if (retried == 0 && this._lastSniff.HasValue &&
 				sniffLifeSpan.HasValue && sniffLifeSpan.Value < (now - this._lastSniff.Value))
-				this.Sniff();
+				this.SniffClusterState();
 		}
 
 		/// <summary>
@@ -70,6 +139,15 @@ private int GetMaximumRetries()
 			return this._configurationValues.MaxRetries.GetValueOrDefault(this._connectionPool.MaxRetries);
 		}
 
+		private bool SniffingDisabled(IRequestConfiguration requestConfiguration)
+		{
+			if (!this._connectionPool.AcceptsUpdates)
+				return true;
+			if (requestConfiguration == null)
+				return false;
+			return requestConfiguration.SniffingDisabled.GetValueOrDefault(false);
+		}
+
 		/* SYNC *** */
 		public ElasticsearchResponse<T> DoRequest<T>(string method, string path, object data = null, IRequestParameters requestParameters = null)
 		{
@@ -86,7 +164,8 @@ public ElasticsearchResponse<T> DoRequest<T>(string method, string path, object
 
 		private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestState, int retried = 0)
 		{
-			SniffIfInformationIsTooOld(retried);
+			if (!SniffingDisabled(requestState.RequestConfiguration))
+				SniffIfInformationIsTooOld(retried);
 
 			IElasticsearchResponse response = null;
 
@@ -100,7 +179,7 @@ private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestSt
 			try
 			{
 				if (shouldPingHint && !this._configurationValues.DisablePings)
-					this._connection.Ping(CreateUriToPath(baseUri, ""));
+					this.Ping(baseUri);
 
 				var streamResponse = _doRequest(requestState.Method, uri, requestState.PostData, requestState.RequestConfiguration);
 				if (streamResponse != null && streamResponse.SuccessOrKnownError)
@@ -134,8 +213,10 @@ private ElasticsearchResponse<T> RetryRequest<T>(TransportRequestState<T> reques
 			var exceptionMessage = MaxRetryExceptionMessage.F(requestState.Method, requestState.Path.IsNullOrEmpty() ? "/" : "", retried);
 
 			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);
-			if (this._configurationValues.SniffsOnConnectionFault && retried == 0)
-				this.Sniff();
+			if (!SniffingDisabled(requestState.RequestConfiguration)
+				&& this._configurationValues.SniffsOnConnectionFault 
+				&& retried == 0)
+				this.SniffClusterState();
 
 			if (retried >= maxRetries) throw new MaxRetryException(exceptionMessage, e);
 
@@ -170,8 +251,14 @@ public Task<ElasticsearchResponse<T>> DoRequestAsync<T>(string method, string pa
 				return this.DoRequestAsync<T>(requestState)
 					.ContinueWith(t =>
 					{
+						var tcs = new TaskCompletionSource<ElasticsearchResponse<T>>();
+						if (t.Exception != null)
+							tcs.SetException(t.Exception.Flatten());
+						else
+							tcs.SetResult(t.Result);
+
 						requestState.Tracer.SetResult(t.Result);
-						return t;
+						return tcs.Task;
 					}).Unwrap();
 			}
 		}
@@ -188,32 +275,38 @@ private Task<ElasticsearchResponse<T>> DoRequestAsync<T>(TransportRequestState<T
 			
 			if (shouldPingHint && !this._configurationValues.DisablePings)
 			{
-				try
-				{
-					this._connection.Ping(CreateUriToPath(baseUri, ""));
-				}
-				catch (Exception e)
-				{
-					return this.RetryRequestAsync<T>(requestState, baseUri, retried, e);
-				}
+				return this.PingAsync(baseUri)
+					.ContinueWith(t =>
+					{
+						if (t.IsCompleted)
+							return this._doRequestAsyncOrRetry(requestState, retried, uri, baseUri);
+
+						return this.RetryRequestAsync(requestState, baseUri, retried, t.Exception);
+					}).Unwrap();
 			}
 			
-			return _doRequestAsync(requestState.Method, uri, requestState.PostData, requestState.RequestConfiguration).ContinueWith(t =>
-			{
-				if (t.IsCanceled)
-					return null;
-				if (t.IsFaulted)
-					return this.RetryRequestAsync<T>(requestState, baseUri, retried, t.Exception);
-				if (t.Result.SuccessOrKnownError)
-					return this.StreamToTypedResponseAsync<T>(t.Result, requestState.DeserializationState)
-						.ContinueWith(tt =>
-						{
-							tt.Result.NumberOfRetries = retried;
-							return tt;
-						}).Unwrap();
-				return this.RetryRequestAsync<T>(requestState, baseUri, retried);
-
-			}).Unwrap();
+			return _doRequestAsyncOrRetry(requestState, retried, uri, baseUri);
+		}
+
+		private Task<ElasticsearchResponse<T>>  _doRequestAsyncOrRetry<T>(
+			TransportRequestState<T> requestState, int retried, Uri uri, Uri baseUri)
+		{
+			return
+				_doRequestAsync(requestState.Method, uri, requestState.PostData, requestState.RequestConfiguration).ContinueWith(t =>
+				{
+					if (t.IsCanceled)
+						return null;
+					if (t.IsFaulted)
+						return this.RetryRequestAsync<T>(requestState, baseUri, retried, t.Exception);
+					if (t.Result.SuccessOrKnownError)
+						return this.StreamToTypedResponseAsync<T>(t.Result, requestState.DeserializationState)
+							.ContinueWith(tt =>
+							{
+								tt.Result.NumberOfRetries = retried;
+								return tt;
+							}).Unwrap();
+					return this.RetryRequestAsync<T>(requestState, baseUri, retried);
+				}).Unwrap();
 		}
 
 		private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(TransportRequestState<T> requestState, Uri baseUri, int retried, Exception e = null)
@@ -224,7 +317,7 @@ private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(TransportRequestStat
 			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);
 
 			if (this._configurationValues.SniffsOnConnectionFault && retried == 0)
-				this.Sniff();
+				this.SniffClusterState();
 
 			if (retried < maxRetries)
 				return this.DoRequestAsync<T>(requestState, ++retried);
diff --git a/src/Elasticsearch.Net/ConnectionPool/IConnectionPool.cs b/src/Elasticsearch.Net/ConnectionPool/IConnectionPool.cs
index e65fb06eda1..0ec0547edd5 100644
--- a/src/Elasticsearch.Net/ConnectionPool/IConnectionPool.cs
+++ b/src/Elasticsearch.Net/ConnectionPool/IConnectionPool.cs
@@ -1,4 +1,6 @@
 using System;
+using System.Collections;
+using System.Collections.Generic;
 using Elasticsearch.Net.Connection;
 
 namespace Elasticsearch.Net.ConnectionPool
@@ -11,11 +13,22 @@ public interface IConnectionPool
 		/// in the connection settings
 		/// </summary>
 		int MaxRetries { get; }
+		
+		/// <summary>
+		/// Signals that this implemenation can accept new nodes
+		/// </summary>
+		bool AcceptsUpdates { get; }
+		
+		/// <summary>
+		/// Signals to the ITransport that this instance has already seen a startup
+		/// </summary>
+		bool HasSeenStartup { get; }
 
 		/// <summary>
 		/// Gets the next live Uri to perform the request on
 		/// </summary>
-		/// <param name="initialSeed">pass the original seed when retrying, this guarantees that the nodes are walked in a predictable manner when multithreading</param>
+		/// <param name="initialSeed">pass the original seed when retrying, this guarantees that the nodes are walked in a
+		///  predictable manner even when called in a multithreaded context</param>
 		/// <param name="seed">The seed this call started on</param>
 		/// <returns></returns>
 		Uri GetNext(int? initialSeed, out int seed, out bool shouldPingHint);
@@ -30,15 +43,12 @@ public interface IConnectionPool
 		/// </summary>
 		/// <param name="uri"></param>
 		void MarkAlive(Uri uri);
-
+		
 		/// <summary>
-		/// Instruct the connectionpool to sniff for more nodes
+		/// Update the node list manually, usually done by ITransport when sniffing was needed.
 		/// </summary>
-		/// <param name="connection">a connection that can be used to call elasticsearch</param>
-		/// <param name="fromStartUpHint">hints wheter the sniff was requested from on startup
-		/// connection pools should be registered as singletons in the application. The hint prevents new'ing of clients
-		/// cause excessive startup sniffs
-		/// </param>
-		void Sniff(IConnection connection, bool fromStartUpHint = false);
+		/// <param name="newClusterState"></param>
+		/// <param name="fromStartupHint">hint that this update came from start up</param>
+		void UpdateNodeList(IList<Uri> newClusterState, bool fromStartupHint = true);
 	}
 }
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/ConnectionPool/SingleNodeConnectionPool.cs b/src/Elasticsearch.Net/ConnectionPool/SingleNodeConnectionPool.cs
index 11933f8e6f5..9559cccfca7 100644
--- a/src/Elasticsearch.Net/ConnectionPool/SingleNodeConnectionPool.cs
+++ b/src/Elasticsearch.Net/ConnectionPool/SingleNodeConnectionPool.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using Elasticsearch.Net.Connection;
 
 namespace Elasticsearch.Net.ConnectionPool
@@ -6,9 +7,16 @@ namespace Elasticsearch.Net.ConnectionPool
 	public class SingleNodeConnectionPool : IConnectionPool
 	{
 		private readonly Uri _uri;
-		
+		private bool _hasSeenStartup;
 		public int MaxRetries { get { return 0;  } }
 
+		public bool AcceptsUpdates { get { return false; } }
+
+		public bool HasSeenStartup
+		{
+			get { return _hasSeenStartup; }
+		}
+
 		public SingleNodeConnectionPool(Uri uri)
 		{
 			//this makes sure that paths stay relative i.e if the root uri is:
@@ -35,9 +43,9 @@ public void MarkAlive(Uri uri)
 			
 		}
 
-		public void Sniff(IConnection connection, bool fromStartupHint = false)
+		public void UpdateNodeList(IList<Uri> newClusterState, bool fromStartupHint = false)
 		{
-			
 		}
+
 	}
 }
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/ConnectionPool/SniffingConnectionPool.cs b/src/Elasticsearch.Net/ConnectionPool/SniffingConnectionPool.cs
index 080ffad2ef1..6c1bfe3f7c7 100644
--- a/src/Elasticsearch.Net/ConnectionPool/SniffingConnectionPool.cs
+++ b/src/Elasticsearch.Net/ConnectionPool/SniffingConnectionPool.cs
@@ -12,6 +12,9 @@ public class SniffingConnectionPool : StaticConnectionPool
 		private readonly ReaderWriterLockSlim _readerWriter = new ReaderWriterLockSlim();
 
 		private bool _seenStartup = false;
+		private bool _canUpdateNodeList;
+
+		public override bool AcceptsUpdates { get { return true; } }
 
 		public SniffingConnectionPool(
 			IEnumerable<Uri> uris, 
@@ -21,26 +24,16 @@ public SniffingConnectionPool(
 		{
 		}
 
-		public override void Sniff(IConnection connection, bool fromStartupHint = false)
+		public override void UpdateNodeList(IList<Uri> newClusterState, bool fromStartupHint = false)
 		{
-			if (fromStartupHint && _seenStartup)
-				return;
+			if (fromStartupHint)
+				this._seenStartup = true;
 
 			try
 			{
-				int seed; bool shouldPingHint;
-				var uri = this.GetNext(null, out seed, out shouldPingHint);
-				
 				this._readerWriter.EnterWriteLock();
-				var nodes = connection.Sniff(uri);
-				if (!nodes.HasAny())
-					return;
-
-				this._nodeUris = nodes;
-				this._uriLookup = nodes.ToDictionary(k => k, v => new EndpointState());
-				if (fromStartupHint)
-					this._seenStartup = true;
-
+				this._nodeUris = newClusterState;
+				this._uriLookup = newClusterState.ToDictionary(k => k, v => new EndpointState());
 			}
 			finally
 			{
diff --git a/src/Elasticsearch.Net/ConnectionPool/StaticConnectionPool.cs b/src/Elasticsearch.Net/ConnectionPool/StaticConnectionPool.cs
index 580ecf0824d..4b9873810bb 100644
--- a/src/Elasticsearch.Net/ConnectionPool/StaticConnectionPool.cs
+++ b/src/Elasticsearch.Net/ConnectionPool/StaticConnectionPool.cs
@@ -9,13 +9,22 @@ namespace Elasticsearch.Net.ConnectionPool
 {
 	public class StaticConnectionPool : IConnectionPool
 	{
+		private readonly IDateTimeProvider _dateTimeProvider;
+		
 		protected IDictionary<Uri, EndpointState> _uriLookup;
 		protected IList<Uri> _nodeUris;
+		protected int _current = -1;
+		protected bool _hasSeenStartup;
+		private bool _canUpdateNodeList;
 
 		public int MaxRetries { get { return _nodeUris.Count - 1;  } }
-		
-		protected int _current = -1;
-		private readonly IDateTimeProvider _dateTimeProvider;
+
+		public virtual bool AcceptsUpdates { get { return false; } }
+
+		public bool HasSeenStartup
+		{
+			get { return _hasSeenStartup; }
+		}
 
 		public StaticConnectionPool(
 			IEnumerable<Uri> uris, 
@@ -95,9 +104,9 @@ public virtual void MarkAlive(Uri uri)
 			}
 		}
 
-		public virtual void Sniff(IConnection connection, bool fromStartupHint = false)
+		public virtual void UpdateNodeList(IList<Uri> newClusterState, bool fromStartupHint = false)
 		{
-			//NOOP on static connection class
 		}
+
 	}
 }
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs b/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
index 7b21ca544ef..54ae30d9aac 100644
--- a/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
+++ b/src/Elasticsearch.Net/Domain/ElasticsearchResponse.cs
@@ -46,7 +46,13 @@ internal static class ElasticsearchResponse
 		public static Task<ElasticsearchResponse<DynamicDictionary>> WrapAsync(Task<ElasticsearchResponse<Dictionary<string, object>>> responseTask)
 		{
 			return responseTask
-				.ContinueWith(t => ToDynamicResponse(t.Result));
+				.ContinueWith(t =>
+				{
+					if (t.IsFaulted)
+						throw t.Exception.Flatten().InnerException;
+
+					return ToDynamicResponse(t.Result);
+				});
 		}
 
 		public static ElasticsearchResponse<DynamicDictionary> Wrap(ElasticsearchResponse<Dictionary<string, object>> response)
diff --git a/src/Elasticsearch.Net/Elasticsearch.Net.csproj b/src/Elasticsearch.Net/Elasticsearch.Net.csproj
index ccd4f17dbcd..da8cdaae075 100644
--- a/src/Elasticsearch.Net/Elasticsearch.Net.csproj
+++ b/src/Elasticsearch.Net/Elasticsearch.Net.csproj
@@ -45,11 +45,14 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Connection\IRequestConfiguration.cs" />
+    <Compile Include="Connection\IRequestConnectionConfiguration.cs" />
     <Compile Include="Connection\TransportRequestState.cs" />
     <Compile Include="Domain\BaseRequestParameters.cs" />
     <Compile Include="Domain\IHideObjectMembers.cs" />
     <Compile Include="Domain\IRequestParameters.cs" />
     <Compile Include="Domain\VoidResponse.cs" />
+    <Compile Include="Extensions\TaskExtensions.cs" />
     <Compile Include="Providers\DateTimeProvider.cs" />
     <Compile Include="Connection\HttpConnection.cs" />
     <Compile Include="Connection\ConnectionError.cs" />
@@ -74,7 +77,7 @@
     <Compile Include="ElasticsearchClient.Generated.cs" />
     <Compile Include="Domain\DynamicDictionary.cs" />
     <Compile Include="Domain\ElasticsearchDynamicValue.cs" />
-    <Compile Include="Exceptions\OutOfNodesException.cs" />
+    <Compile Include="Exceptions\MaxRetryException.cs" />
     <Compile Include="Extensions\DateExtensions.cs" />
     <Compile Include="Extensions\Extensions.cs" />
     <Compile Include="Extensions\NameValueCollectionExtensions.cs" />
diff --git a/src/Elasticsearch.Net/ElasticsearchClient.cs b/src/Elasticsearch.Net/ElasticsearchClient.cs
index 87a763d909e..cf2fb5e8257 100644
--- a/src/Elasticsearch.Net/ElasticsearchClient.cs
+++ b/src/Elasticsearch.Net/ElasticsearchClient.cs
@@ -45,8 +45,7 @@ public ElasticsearchClient(
 			
 			//neccessary to pass the serializer to ElasticsearchResponse
 			this.Settings.Serializer = this.Transport.Serializer;
-			if (this.Settings.SniffsOnStartup)
-				this.Transport.Sniff(fromStartup: true);
+		
 		}
 
 		protected void ToNameValueCollection(BaseRequestParameters requestParameters)
diff --git a/src/Elasticsearch.Net/Exceptions/OutOfNodesException.cs b/src/Elasticsearch.Net/Exceptions/MaxRetryException.cs
similarity index 78%
rename from src/Elasticsearch.Net/Exceptions/OutOfNodesException.cs
rename to src/Elasticsearch.Net/Exceptions/MaxRetryException.cs
index c9c7f155e8e..ddaba3267f0 100644
--- a/src/Elasticsearch.Net/Exceptions/OutOfNodesException.cs
+++ b/src/Elasticsearch.Net/Exceptions/MaxRetryException.cs
@@ -5,6 +5,10 @@
 
 namespace Elasticsearch.Net.Exceptions
 {
+
+	/// <summary>
+	/// Thrown when a request has depleeded its max retry setting
+	/// </summary>
 	public class MaxRetryException : Exception
 	{
 		public MaxRetryException(string message) : base(message)
@@ -16,4 +20,6 @@ public MaxRetryException(string message, Exception innerException) : base(messag
 			
 		}
 	}
+	
+	
 }
diff --git a/src/Elasticsearch.Net/Extensions/TaskExtensions.cs b/src/Elasticsearch.Net/Extensions/TaskExtensions.cs
new file mode 100644
index 00000000000..5cd07fd3dac
--- /dev/null
+++ b/src/Elasticsearch.Net/Extensions/TaskExtensions.cs
@@ -0,0 +1,294 @@
+// Copyright (c) 2012 Rizal Almashoor
+// Licensed under the MIT license.
+// http://gist.github.com/2818038#file_license.txt
+
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+
+namespace Elasticsearch.Net
+{
+	internal static class TaskHelper
+	{
+		// Inspired by http://blogs.msdn.com/b/pfxteam/archive/2010/11/21/10094564.aspx
+
+		public static Task Then(this Task task, Action<Task> next)
+		{
+			if (task == null) throw new ArgumentNullException("task");
+			if (next == null) throw new ArgumentNullException("next");
+
+			var tcs = new TaskCompletionSource<AsyncVoid>();
+
+			task.ContinueWith(previousTask =>
+			{
+				if (previousTask.IsFaulted) tcs.TrySetException(previousTask.Exception);
+				else if (previousTask.IsCanceled) tcs.TrySetCanceled();
+				else
+				{
+					try
+					{
+						next(previousTask);
+						tcs.TrySetResult(default(AsyncVoid));
+					}
+					catch (Exception ex)
+					{
+						tcs.TrySetException(ex);
+					}
+				}
+			});
+
+			return tcs.Task;
+		}
+
+		public static Task Then(this Task task, Func<Task, Task> next)
+		{
+			if (task == null) throw new ArgumentNullException("task");
+			if (next == null) throw new ArgumentNullException("next");
+
+			var tcs = new TaskCompletionSource<AsyncVoid>();
+
+			task.ContinueWith(previousTask =>
+			{
+				if (previousTask.IsFaulted) tcs.TrySetException(previousTask.Exception);
+				else if (previousTask.IsCanceled) tcs.TrySetCanceled();
+				else
+				{
+					try
+					{
+						next(previousTask).ContinueWith(nextTask =>
+						{
+							if (nextTask.IsFaulted) tcs.TrySetException(nextTask.Exception);
+							else if (nextTask.IsCanceled) tcs.TrySetCanceled();
+							else tcs.TrySetResult(default(AsyncVoid));
+						});
+					}
+					catch (Exception ex)
+					{
+						tcs.TrySetException(ex);
+					}
+				}
+			});
+
+			return tcs.Task;
+		}
+
+		public static Task<TNextResult> Then<TNextResult>(this Task task, Func<Task, TNextResult> next)
+		{
+			if (task == null) throw new ArgumentNullException("task");
+			if (next == null) throw new ArgumentNullException("next");
+
+			var tcs = new TaskCompletionSource<TNextResult>();
+
+			task.ContinueWith(previousTask =>
+			{
+				if (previousTask.IsFaulted) tcs.TrySetException(previousTask.Exception);
+				else if (previousTask.IsCanceled) tcs.TrySetCanceled();
+				else
+				{
+					try
+					{
+						tcs.TrySetResult(next(previousTask));
+					}
+					catch (Exception ex)
+					{
+						tcs.TrySetException(ex);
+					}
+				}
+			});
+
+			return tcs.Task;
+		}
+
+		public static Task<TNextResult> Then<TNextResult>(this Task task, Func<Task, Task<TNextResult>> next)
+		{
+			if (task == null) throw new ArgumentNullException("task");
+			if (next == null) throw new ArgumentNullException("next");
+
+			var tcs = new TaskCompletionSource<TNextResult>();
+
+			task.ContinueWith(previousTask =>
+			{
+				if (previousTask.IsFaulted) tcs.TrySetException(previousTask.Exception);
+				else if (previousTask.IsCanceled) tcs.TrySetCanceled();
+				else
+				{
+					try
+					{
+						next(previousTask).ContinueWith(nextTask =>
+						{
+							if (nextTask.IsFaulted) tcs.TrySetException(nextTask.Exception);
+							else if (nextTask.IsCanceled) tcs.TrySetCanceled();
+							else
+							{
+								try
+								{
+									tcs.TrySetResult(nextTask.Result);
+								}
+								catch (Exception ex)
+								{
+									tcs.TrySetException(ex);
+								}
+							}
+						});
+					}
+					catch (Exception ex)
+					{
+						tcs.TrySetException(ex);
+					}
+				}
+			});
+
+			return tcs.Task;
+		}
+
+		public static Task Then<TResult>(this Task<TResult> task, Action<Task<TResult>> next)
+		{
+			if (task == null) throw new ArgumentNullException("task");
+			if (next == null) throw new ArgumentNullException("next");
+
+			var tcs = new TaskCompletionSource<AsyncVoid>();
+
+			task.ContinueWith(previousTask =>
+			{
+				if (previousTask.IsFaulted) tcs.TrySetException(previousTask.Exception);
+				else if (previousTask.IsCanceled) tcs.TrySetCanceled();
+				else
+				{
+					try
+					{
+						next(previousTask);
+						tcs.TrySetResult(default(AsyncVoid));
+					}
+					catch (Exception ex)
+					{
+						tcs.TrySetException(ex);
+					}
+				}
+			});
+
+			return tcs.Task;
+		}
+
+		public static Task Then<TResult>(this Task<TResult> task, Func<Task<TResult>, Task> next)
+		{
+			if (task == null) throw new ArgumentNullException("task");
+			if (next == null) throw new ArgumentNullException("next");
+
+			var tcs = new TaskCompletionSource<AsyncVoid>();
+
+			task.ContinueWith(previousTask =>
+			{
+				if (previousTask.IsFaulted) tcs.TrySetException(previousTask.Exception);
+				else if (previousTask.IsCanceled) tcs.TrySetCanceled();
+				else
+				{
+					try
+					{
+						next(previousTask).ContinueWith(nextTask =>
+						{
+							if (nextTask.IsFaulted) tcs.TrySetException(nextTask.Exception);
+							else if (nextTask.IsCanceled) tcs.TrySetCanceled();
+							else tcs.TrySetResult(default(AsyncVoid));
+						});
+					}
+					catch (Exception ex)
+					{
+						tcs.TrySetException(ex);
+					}
+				}
+			});
+
+			return tcs.Task;
+		}
+
+		public static Task<TNextResult> Then<TResult, TNextResult>(this Task<TResult> task, Func<Task<TResult>, TNextResult> next)
+		{
+			if (task == null) throw new ArgumentNullException("task");
+			if (next == null) throw new ArgumentNullException("next");
+
+			var tcs = new TaskCompletionSource<TNextResult>();
+
+			task.ContinueWith(previousTask =>
+			{
+				if (previousTask.IsFaulted) tcs.TrySetException(previousTask.Exception);
+				else if (previousTask.IsCanceled) tcs.TrySetCanceled();
+				else
+				{
+					try
+					{
+						tcs.TrySetResult(next(previousTask));
+					}
+					catch (Exception ex)
+					{
+						tcs.TrySetException(ex);
+					}
+				}
+			});
+
+			return tcs.Task;
+		}
+
+		public static Task<TNextResult> Then<TResult, TNextResult>(this Task<TResult> task, Func<Task<TResult>, Task<TNextResult>> next)
+		{
+			if (task == null) throw new ArgumentNullException("task");
+			if (next == null) throw new ArgumentNullException("next");
+
+			var tcs = new TaskCompletionSource<TNextResult>();
+
+			task.ContinueWith(previousTask =>
+			{
+				if (previousTask.IsFaulted) tcs.TrySetException(previousTask.Exception);
+				else if (previousTask.IsCanceled) tcs.TrySetCanceled();
+				else
+				{
+					try
+					{
+						next(previousTask).ContinueWith(nextTask =>
+						{
+							if (nextTask.IsFaulted) tcs.TrySetException(nextTask.Exception);
+							else if (nextTask.IsCanceled) tcs.TrySetCanceled();
+							else
+							{
+								try
+								{
+									tcs.TrySetResult(nextTask.Result);
+								}
+								catch (Exception ex)
+								{
+									tcs.TrySetException(ex);
+								}
+							}
+						});
+					}
+					catch (Exception ex)
+					{
+						tcs.TrySetException(ex);
+					}
+				}
+			});
+
+			return tcs.Task;
+		}
+
+		/// <summary>
+		/// Analogous to the finally block in a try/finally
+		/// </summary>
+		public static void Finally(this Task task, Action<Exception> exceptionHandler, Action finalAction = null)
+		{
+			task.ContinueWith(t =>
+			{
+				if (finalAction != null) finalAction();
+
+				if (t.IsCanceled || !t.IsFaulted || exceptionHandler == null) return;
+				var innerException = t.Exception.Flatten().InnerExceptions.FirstOrDefault();
+				exceptionHandler(innerException ?? t.Exception);
+			});
+		}
+	}
+
+	public struct AsyncVoid
+	{
+		// Based on Brad Wilson's idea, to simulate a non-generic TaskCompletionSource
+		// http://bradwilson.typepad.com/blog/2012/04/tpl-and-servers-pt4.html
+	}
+}
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs
index ff3ab5080c9..61233af8705 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/ConcurrencyTests.cs
@@ -130,15 +130,7 @@ public ConcurrencyTestConnection(IConnectionConfigurationValues settings)
 			{
 			}
 
-			public override bool Ping(Uri uri)
-			{
-				return true;
-			}
-
-			public override IList<Uri> Sniff(Uri uri)
-			{
-				return  _rnd.Next(1, 11) % 3 == 0 ? _uris : _uris2;
-			}
+		
 
 			public override ElasticsearchResponse<Stream> GetSync(Uri uri, IRequestConnectionConfiguration requestConfigurationOverrides = null)
 			{
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs
index 5100b569b8a..8f4c6ac8f9b 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/RetryTests.cs
@@ -69,11 +69,7 @@ public async void ThrowsOutOfNodesException_AndRetriesTheSpecifiedTimes_Async()
 				{
 					var result = await client.InfoAsync();
 				}
-				catch (AggregateException ae)
-				{
-					Assert.AreEqual(typeof(MaxRetryException), ae.InnerException.GetType());
-				}
-				catch (Exception e)
+				catch (MaxRetryException e)
 				{
 					Assert.AreEqual(typeof(MaxRetryException), e.GetType());
 				}
@@ -192,11 +188,7 @@ public async void ShouldRetryOn503_Async()
 				{
 					var result = await client.InfoAsync();
 				}
-				catch (AggregateException e)
-				{
-					Assert.AreEqual(e.InnerException.GetType(), typeof(MaxRetryException));
-				}
-				catch (Exception e)
+				catch (MaxRetryException e)
 				{
 					Assert.AreEqual(e.GetType(), typeof(MaxRetryException));
 				}
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs
index f6bfc613cf5..a4bb57d8c69 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SkipDeadNodesTests.cs
@@ -49,10 +49,10 @@ public void DeadNodesAreNotVisited_AndPingedAppropiately()
 				);
 				
 				var seenNodes = new List<Uri>();
-				getCall.Invokes((Uri u, IRequestConfiguration o) => seenNodes.Add(u));
+				getCall.Invokes((Uri u, IRequestConnectionConfiguration o) => seenNodes.Add(u));
 
-				var pingCall = FakeCalls.Ping(fake);
-				pingCall.Returns(true);
+				var pingCall = FakeCalls.PingAtConnectionLevel(fake);
+				pingCall.Returns(ok);
 
 				var client1 = fake.Resolve<ElasticsearchClient>();
 				client1.Info(); //info call 1
@@ -100,10 +100,10 @@ public async void DeadNodesAreNotVisited_AndPingedAppropiately_Async()
 				);
 				
 				var seenNodes = new List<Uri>();
-				getCall.Invokes((Uri u, IRequestConfiguration o) => seenNodes.Add(u));
+				getCall.Invokes((Uri u, IRequestConnectionConfiguration o) => seenNodes.Add(u));
 
-				var pingCall = FakeCalls.Ping(fake);
-				pingCall.Returns(true);
+				var pingCall = FakeCalls.PingAtConnectionLevelAsync(fake);
+				pingCall.Returns(ok);
 
 				var client1 = fake.Resolve<ElasticsearchClient>();
 				await client1.InfoAsync(); //info call 1
@@ -126,10 +126,12 @@ public async void DeadNodesAreNotVisited_AndPingedAppropiately_Async()
 		private static IConnection ProvideConnection(AutoFake fake, ConnectionConfiguration config)
 		{
 			fake.Provide<IConnectionConfigurationValues>(config);
-			fake.Provide<ITransport>(fake.Resolve<Transport>());
+			var param = new TypedParameter(typeof(IDateTimeProvider), null);
+			var transport = fake.Provide<ITransport, Transport>(param);
 			var connection = fake.Resolve<IConnection>();
 			return connection;
 		}
+
 		private static ConnectionConfiguration ProvideConfiguration(IDateTimeProvider dateTimeProvider)
 		{
 			var connectionPool = new StaticConnectionPool(new[]
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
index 056cbd637ea..f2b592373ce 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/SniffingConnectionPoolTests.cs
@@ -9,9 +9,11 @@
 using Elasticsearch.Net.ConnectionPool;
 using Elasticsearch.Net.Exceptions;
 using Elasticsearch.Net.Providers;
+using Elasticsearch.Net.Serialization;
 using Elasticsearch.Net.Tests.Unit.Stubs;
 using FakeItEasy;
 using FakeItEasy.Configuration;
+using FakeItEasy.Core;
 using FluentAssertions;
 using NUnit.Framework;
 
@@ -27,18 +29,18 @@ public void SniffOnStartupCallsSniffOnlyOnce()
 			{
 				//It's recommended to only have on instance of your connection pool
 				//Be sure to register it as Singleton in your IOC
-				var connectionPool = new SniffingConnectionPool(new[] { new Uri("http://localhost:9200") });
+				var uris = new[] { new Uri("http://localhost:9200") };
+				var connectionPool = new SniffingConnectionPool(uris);
 				var config = new ConnectionConfiguration(connectionPool)
+					.DisablePing()
 					.SniffOnStartup();
 				fake.Provide<IConnectionConfigurationValues>(config);
-				var param = new TypedParameter(typeof(IDateTimeProvider), null);
-				fake.Provide<ITransport, Transport>(param);
-				var connection = fake.Resolve<IConnection>();
-				var sniffCall = A.CallTo(() => connection.Sniff(A<Uri>._));
-				var client1 = fake.Resolve<ElasticsearchClient>(); 
-				var client2 = fake.Resolve<ElasticsearchClient>(); 
-				var client3 = fake.Resolve<ElasticsearchClient>(); 
-				var client4 = fake.Resolve<ElasticsearchClient>(); 
+				var sniffCall = FakeCalls.Sniff(fake, config, uris);
+				var transport = FakeCalls.ProvideDefaultTransport(fake);
+				var client1 = new ElasticsearchClient(config, transport: transport); 
+				var client2 = new ElasticsearchClient(config, transport: transport); 
+				var client3 = new ElasticsearchClient(config, transport: transport); 
+				var client4 = new ElasticsearchClient(config, transport: transport); 
 
 				sniffCall.MustHaveHappened(Repeated.Exactly.Once);
 			}
@@ -61,13 +63,14 @@ public void SniffIsCalledAfterItHasGoneOutOfDate()
 					DateTime.UtcNow.AddMinutes(20), //set now after sniff 4
 					DateTime.UtcNow.AddMinutes(22) //info call 5
 				);
-				var connectionPool = new SniffingConnectionPool(new[] { new Uri("http://localhost:9200") });
+				var uris = new[] { new Uri("http://localhost:9200") };
+				var connectionPool = new SniffingConnectionPool(uris);
 				var config = new ConnectionConfiguration(connectionPool)
 					.SniffLifeSpan(TimeSpan.FromMinutes(4));
 				fake.Provide<IConnectionConfigurationValues>(config);
-				fake.Provide<ITransport>(fake.Resolve<Transport>());
+				var transport = FakeCalls.ProvideDefaultTransport(fake, dateTimeProvider);
 				var connection = fake.Resolve<IConnection>();
-				var sniffCall = A.CallTo(() => connection.Sniff(A<Uri>._));
+				var sniffCall = FakeCalls.Sniff(fake, config, uris);
 				
 				var getCall = FakeCalls.GetSyncCall(fake);
 				getCall.Returns(FakeResponse.Ok(config));
@@ -81,8 +84,6 @@ public void SniffIsCalledAfterItHasGoneOutOfDate()
 
 				sniffCall.MustHaveHappened(Repeated.Exactly.Twice);
 				nowCall.MustHaveHappened(Repeated.Exactly.Times(8));
-
-				//var nowCall = A.CallTo(() => fake.Resolve<IDateTimeProvider>().Sniff(A<Uri>._, A<int>._));
 			}
 		}
 		
@@ -102,13 +103,14 @@ public void SniffIsCalledAfterItHasGoneOutOfDate_NotWhenItSeesA503()
 					DateTime.UtcNow.AddMinutes(10), //info call 4
 					DateTime.UtcNow.AddMinutes(12) //info call 5
 				);
-				var connectionPool = new SniffingConnectionPool(new[] { new Uri("http://localhost:9200") });
+				var uris = new[] { new Uri("http://localhost:9200") };
+				var connectionPool = new SniffingConnectionPool(uris);
 				var config = new ConnectionConfiguration(connectionPool)
-					.SniffLifeSpan(TimeSpan.FromMinutes(4));
+					.SniffLifeSpan(TimeSpan.FromMinutes(4))
+					.ExposeRawResponse();
 				fake.Provide<IConnectionConfigurationValues>(config);
-				fake.Provide<ITransport>(fake.Resolve<Transport>());
-				var connection = fake.Resolve<IConnection>();
-				var sniffCall = A.CallTo(() => connection.Sniff(A<Uri>._));
+				var transport = FakeCalls.ProvideDefaultTransport(fake, dateTimeProvider);
+				var sniffCall = FakeCalls.Sniff(fake, config, uris);
 				var getCall = FakeCalls.GetSyncCall(fake);
 				getCall.ReturnsNextFromSequence(
 					FakeResponse.Ok(config), //info 1
@@ -141,14 +143,14 @@ public void SniffOnConnectionFaultCausesSniffOn503()
 				var dateTimeProvider = fake.Resolve<IDateTimeProvider>();
 				var nowCall = A.CallTo(()=>dateTimeProvider.Now());
 				nowCall.Returns(DateTime.UtcNow);
-
-				var connectionPool = new SniffingConnectionPool(new[] { new Uri("http://localhost:9200") });
+				var nodes = new[] { new Uri("http://localhost:9200") };
+				var connectionPool = new SniffingConnectionPool(nodes);
 				var config = new ConnectionConfiguration(connectionPool)
 					.SniffOnConnectionFault();
 				fake.Provide<IConnectionConfigurationValues>(config);
-				fake.Provide<ITransport>(fake.Resolve<Transport>());
+				var transport = FakeCalls.ProvideDefaultTransport(fake, dateTimeProvider);
 				var connection = fake.Resolve<IConnection>();
-				var sniffCall = A.CallTo(() => connection.Sniff(A<Uri>._));
+				var sniffCall = FakeCalls.Sniff(fake, config, nodes);
 				var getCall = FakeCalls.GetSyncCall(fake);
 				getCall.ReturnsNextFromSequence(
 					
@@ -169,7 +171,6 @@ public void SniffOnConnectionFaultCausesSniffOn503()
 				sniffCall.MustHaveHappened(Repeated.Exactly.Once);
 				nowCall.MustHaveHappened(Repeated.Exactly.Times(7));
 
-				//var nowCall = A.CallTo(() => fake.Resolve<IDateTimeProvider>().Sniff(A<Uri>._, A<int>._));
 			}
 		}
 		[Test]
@@ -189,9 +190,11 @@ public void HostsReturnedBySniffAreVisited()
 				var config = new ConnectionConfiguration(connectionPool)
 					.SniffOnConnectionFault();
 				fake.Provide<IConnectionConfigurationValues>(config);
-				var connection = fake.Resolve<IConnection>();
-				var sniffCall = A.CallTo(() => connection.Sniff(A<Uri>._));
-				sniffCall.Returns(new List<Uri>()
+				FakeCalls.ProvideDefaultTransport(fake);
+				FakeCalls.PingAtConnectionLevel(fake)
+					.Returns(FakeResponse.Ok(config));
+				
+				var sniffCall = FakeCalls.Sniff(fake, config, new List<Uri>()
 				{
 					new Uri("http://localhost:9204"),
 					new Uri("http://localhost:9203"),
@@ -199,9 +202,12 @@ public void HostsReturnedBySniffAreVisited()
 					new Uri("http://localhost:9201")
 				});
 
+				var connection = fake.Resolve<IConnection>();
 				var seenNodes = new List<Uri>();
 				//var getCall =  FakeResponse.GetSyncCall(fake);
-				var getCall = A.CallTo(() => connection.GetSync(A<Uri>._, A<IRequestConfiguration>._));
+				var getCall = A.CallTo(() => connection.GetSync(
+					A<Uri>.That.Not.Matches(u=>u.AbsolutePath.StartsWith("/_nodes")), 
+					A<IRequestConfiguration>._));
 				getCall.ReturnsNextFromSequence(
 					FakeResponse.Ok(config), //info 1
 					FakeResponse.Bad(config), //info 2
@@ -214,9 +220,8 @@ public void HostsReturnedBySniffAreVisited()
 					FakeResponse.Ok(config), //info 8
 					FakeResponse.Ok(config) //info 9
 				);
-				getCall.Invokes((Uri u, IRequestConfiguration o) => seenNodes.Add(u));
+				getCall.Invokes((Uri u, IRequestConnectionConfiguration o) => seenNodes.Add(u));
 
-				fake.Provide<ITransport>(fake.Resolve<Transport>());
 				var client1 = fake.Resolve<ElasticsearchClient>();
 				client1.Info(); //info call 1
 				client1.Info(); //info call 2
@@ -233,13 +238,11 @@ public void HostsReturnedBySniffAreVisited()
 				seenNodes[0].Port.Should().Be(9200);
 				seenNodes[1].Port.Should().Be(9201);
 				//after sniff
-				seenNodes[2].Port.Should().Be(9202);
-				seenNodes[3].Port.Should().Be(9204, string.Join(",", seenNodes.Select(n=>n.Port)));
+				seenNodes[2].Port.Should().Be(9202, string.Join(",", seenNodes.Select(n=>n.Port)));
+				seenNodes[3].Port.Should().Be(9204);
 				seenNodes[4].Port.Should().Be(9203);
 				seenNodes[5].Port.Should().Be(9202);
 				seenNodes[6].Port.Should().Be(9201);
-
-				//var nowCall = A.CallTo(() => fake.Resolve<IDateTimeProvider>().Sniff(A<Uri>._, A<int>._));
 			}
 		}
 	}
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs
index 31c56e1d145..09b864ce6c4 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Connection/StaticConnectionPoolRetryTests.cs
@@ -32,18 +32,25 @@ public class StaticConnectionPoolRetryTests
 		private static readonly int _retries = _uris.Count() - 1;
 		private readonly StaticConnectionPool _connectionPool;
 		private readonly ConnectionConfiguration _config;
+		private ElasticsearchResponse<Stream> _ok;
+		private ElasticsearchResponse<Stream> _bad;
+
 
 		public StaticConnectionPoolRetryTests()
 		{
 			_connectionPool = new StaticConnectionPool(_uris);
 			_config = new ConnectionConfiguration(_connectionPool);
+
+			_ok = FakeResponse.Ok(_config);
+			_bad = FakeResponse.Bad(_config);
 		}
 
-		private void ProvideTransport(AutoFake fake)
+		private ITransport ProvideTransport(AutoFake fake)
 		{
 			var param = new TypedParameter(typeof(IDateTimeProvider), null);
-			fake.Provide<ITransport, Transport>(param);
+			return fake.Provide<ITransport, Transport>(param);
 		}
+
 		[Test]
 		public void ThrowsOutOfNodesException_AndRetriesTheSpecifiedTimes()
 		{
@@ -60,8 +67,8 @@ public void ThrowsOutOfNodesException_AndRetriesTheSpecifiedTimes()
 				//an exception
 				var getCall = FakeCalls.GetSyncCall(fake);
 				getCall.Throws<Exception>();
-				var pingCall = FakeCalls.Ping(fake);
-				pingCall.Returns(true);
+				var pingCall = FakeCalls.PingAtConnectionLevel(fake);
+				pingCall.Returns(_ok);
 				
 				//create a real ElasticsearchClient with it unspecified dependencies
 				//as fakes
@@ -129,10 +136,10 @@ public void HardRetryLimitTakesPrecedenceOverNumberOfNodes()
 				var getCall = A.CallTo(() => 
 					fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IRequestConfiguration>._));
 				getCall.Throws<Exception>();
-				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
-				pingCall.Returns(true);
 
-				this.ProvideTransport(fake);
+				var transport = this.ProvideTransport(fake);
+				var pingCall = FakeCalls.PingAtConnectionLevel(fake);
+				pingCall.Returns(_ok);
 
 				var client = fake.Resolve<ElasticsearchClient>();
 
@@ -160,16 +167,16 @@ public void AConnectionMustBeMadeEvenIfAllNodesAreDead()
 				//set up our GET to / to return 4 503's followed by a 200
 				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IRequestConfiguration>._));
 				getCall.ReturnsNextFromSequence(
-					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Stream>.Create(_config, 200, "GET", "/", null)
+					_bad,
+					_bad,
+					_bad,
+					_bad,
+					_ok
 				);
-				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
-				pingCall.Returns(true);
+				var transport = this.ProvideTransport(fake);
+				var pingCall = FakeCalls.PingAtConnectionLevel(fake);
+				pingCall.Returns(_ok);
 				//setup client
-				this.ProvideTransport(fake);
 				var client = fake.Resolve<ElasticsearchClient>();
 				
 				//Do not throw because by miracle the 4th retry manages to give back a 200
@@ -216,13 +223,11 @@ public void AllNodesWillBeMarkedDead()
 				
 				//When we do a GET on / we always recieve a 503
 				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IRequestConfiguration>._));
-				getCall.Returns(
-					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null)
-				);
+				getCall.Returns(_bad);
 				
-				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
-				pingCall.Returns(true);
-				this.ProvideTransport(fake);
+				var transport = this.ProvideTransport(fake);
+				var pingCall = FakeCalls.PingAtConnectionLevel(fake);
+				pingCall.Returns(_ok);
 				var client = fake.Resolve<ElasticsearchClient>();
 				
 				//Since we always get a 503 we should see an out of nodes exception
@@ -262,20 +267,19 @@ public void IfAConnectionComesBackToLifeOnItsOwnItShouldBeMarked()
 
 				//fake getsync handler that return a 503 4 times and then a 200
 				//this will cause all 4 nodes to be marked dead on the first client call
-				var getCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, A<IRequestConfiguration>._));
+				var getCall = FakeCalls.GetSyncCall(fake);
 				getCall.ReturnsNextFromSequence(
-					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Stream>.Create(_config, 503, "GET", "/", null),
-					ElasticsearchResponse<Stream>.Create(_config, 200, "GET", "/", null)
+					_bad,
+					_bad,
+					_bad,
+					_bad,
+					_ok
 				);
-				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
-				pingCall.Returns(true);
-
-
 				//provide a transport with all the dependencies resolved
-				this.ProvideTransport(fake);
+				var transport = this.ProvideTransport(fake);
+				var pingCall = FakeCalls.PingAtConnectionLevel(fake);
+				pingCall.Returns(_ok);
+
 				//instantiate connection with faked dependencies
 				var client = fake.Resolve<ElasticsearchClient>();
 				
@@ -340,11 +344,11 @@ public void IfAllButOneConnectionDiesSubsequentRequestsMustUseTheOneAliveConnect
 					FakeResponse.Ok(config),
 					FakeResponse.Ok(config)
 				);
-				var pingCall = A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
-				pingCall.Returns(true);
-				
 				//provide a transport with all the dependencies resolved
-				this.ProvideTransport(fake);
+				var transport = this.ProvideTransport(fake);
+				var pingCall = FakeCalls.PingAtConnectionLevel(fake);
+				pingCall.Returns(_ok);
+				
 				//instantiate connection with faked dependencies
 				var client = fake.Resolve<ElasticsearchClient>();
 				
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
index a9baa9fb567..b07e4562581 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
@@ -2,11 +2,15 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Text;
 using System.Threading.Tasks;
 using Autofac;
 using Autofac.Extras.FakeItEasy;
 using Elasticsearch.Net.Connection;
 using Elasticsearch.Net.Providers;
+using Elasticsearch.Net.Serialization;
 using FakeItEasy;
 using FakeItEasy.Configuration;
 
@@ -16,22 +20,84 @@ public static class FakeCalls
 	{
 		public static IReturnValueConfiguration<ElasticsearchResponse<Stream>> GetSyncCall(AutoFake fake)
 		{
-			return A.CallTo(() => fake.Resolve<IConnection>().GetSync(A<Uri>._, null));
+			return A.CallTo(() => 
+				fake.Resolve<IConnection>().GetSync(A<Uri>.That.Not.Matches(IsSniffUrl()), null));
 		}
 		public static IReturnValueArgumentValidationConfiguration<Task<ElasticsearchResponse<Stream>>> GetCall(AutoFake fake)
 		{
-			return A.CallTo(() => fake.Resolve<IConnection>().Get(A<Uri>._, null));
+			return A.CallTo(() => fake.Resolve<IConnection>().Get(A<Uri>.That.Not.Matches(IsSniffUrl()), null));
+		}
+		
+		public static IReturnValueConfiguration<ElasticsearchResponse<Stream>> PingAtConnectionLevel(AutoFake fake)
+		{
+			return A.CallTo(() => fake.Resolve<IConnection>().HeadSync(
+				A<Uri>.That.Matches(u=>u.AbsolutePath == "/"), A<RequestConnectionConfiguration>._));
+		}
+		public static IReturnValueConfiguration<Task<ElasticsearchResponse<Stream>>> PingAtConnectionLevelAsync(AutoFake fake)
+		{
+			return A.CallTo(() => fake.Resolve<IConnection>().Head(
+				A<Uri>.That.Matches(u=>u.AbsolutePath == "/"), A<RequestConnectionConfiguration>._));
+		}
+		
+		public static IReturnValueConfiguration<ElasticsearchResponse<Stream>> Sniff(
+			AutoFake fake, 
+			IConnectionConfigurationValues configurationValues = null,
+			IList<Uri> nodes = null)
+		{
+			var sniffCall = A.CallTo(() => fake.Resolve<IConnection>().GetSync(
+				A<Uri>.That.Matches(IsSniffUrl()), 
+				A<IRequestConnectionConfiguration>._));
+			if (nodes == null) return sniffCall;
+			sniffCall.ReturnsLazily(()=>
+			{
+				
+				var stream = SniffResponse(nodes);
+				var response = FakeResponse.Ok(configurationValues, "GET", "/_nodes/_all/clear", stream);
+				return response;
+			});
+
+			return sniffCall;
 		}
 
-		public static IReturnValueArgumentValidationConfiguration<bool> Ping(AutoFake fake)
+		private static Expression<Func<Uri, bool>> IsSniffUrl()
 		{
-			return A.CallTo(() => fake.Resolve<IConnection>().Ping(A<Uri>._));
+			return u=>u.AbsolutePath.StartsWith("/_nodes/_all");
 		}
 
-		public static ITransport ProvideDefaultTransport(AutoFake fake)
+		public static IReturnValueConfiguration<Task<ElasticsearchResponse<Stream>>> SniffAsync(
+			AutoFake fake, 
+			IConnectionConfigurationValues configurationValues = null,
+			IList<Uri> nodes = null
+			)
 		{
-			var param = new TypedParameter(typeof(IDateTimeProvider), null);
-			return fake.Provide<ITransport, Transport>(param);
+			var sniffCall = A.CallTo(() => fake.Resolve<IConnection>().Get(
+				A<Uri>.That.Matches(IsSniffUrl()), 
+				A<IRequestConnectionConfiguration>._));
+			if (nodes == null) return sniffCall;
+			var stream = SniffResponse(nodes);
+			var response = FakeResponse.Ok(configurationValues, "GET", "/_nodes/_all/clear", stream);
+			sniffCall.Returns(Task.FromResult(response));
+			return sniffCall;
+		}
+		
+		
+
+		public static ITransport ProvideDefaultTransport(AutoFake fake, IDateTimeProvider dateTimeProvider = null)
+		{
+			var param = new TypedParameter(typeof(IDateTimeProvider), dateTimeProvider);
+			var serializerParam = new TypedParameter(typeof(IElasticsearchSerializer), null);
+			return fake.Provide<ITransport, Transport>(param, serializerParam);
+		}
+
+		private static readonly string SniffFormat = @" {{ ""cluster_name"" : ""insert_marvel_character"", ""nodes"" : {{ {0} }} }}";
+		private static readonly string NodeFormat = @" ""{0}"" : {{ ""name"" : ""node_{1}"", ""http_address"" : ""inet[/{2}]"" }}";
+		private static Stream SniffResponse(IList<Uri> nodes)
+		{
+			var nodesFormatted = nodes
+				.Select((n, i)=> string.Format(NodeFormat, Guid.NewGuid().ToString(), i, n.Host + ":" + n.Port));
+			var sniffFormatted = string.Format(SniffFormat, String.Join(",", nodesFormatted));
+			return new MemoryStream(Encoding.UTF8.GetBytes(sniffFormatted));
+
 		}
 
 	}
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeResponse.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeResponse.cs
index d62881aed74..7b0a04e0584 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeResponse.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeResponse.cs
@@ -9,9 +9,10 @@ public static class FakeResponse
 		public static ElasticsearchResponse<Stream> Ok(
 			IConnectionConfigurationValues config, 
 			string method = "GET",
-			string path = "/")
+			string path = "/",
+			Stream response = null)
 		{
-			return ElasticsearchResponse<Stream>.Create(config, 200, method, path, null);
+			return ElasticsearchResponse<Stream>.Create(config, 200, method, path, null, response);
 		}
 		
 		public static ElasticsearchResponse<Stream> Bad(
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs
index d14aa001283..671b65bbc9b 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/NoopConnection.cs
@@ -119,16 +119,6 @@ public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IR
 			return _responseGenerator.Create();
 		}
 
-		public bool Ping(Uri uri)
-		{
-			return true;
-		}
-
-		public IList<Uri> Sniff(Uri uri)
-		{
-			throw new NotImplementedException();
-		}
-
 		private Task<ElasticsearchResponse<Stream>> DoAsyncRequest(Uri uri)
 		{
 			_uriObserver.Observe(uri);

From f112f825e9290907b1a0dd549b7cb0412d6721a4 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 12:03:24 +0200
Subject: [PATCH 09/20] NEST descriptors now also expose RequestConfiguration

---
 .../Domain/FluentRequestParameters.cs         |  7 +++++-
 src/Nest/DSL/BulkDescriptor.cs                |  2 +-
 src/Nest/DSL/Paths/BasePathDescriptor.cs      | 22 +++++++++++++++++++
 src/Nest/DSL/Paths/DocumentPathDescriptor.cs  |  3 ++-
 .../DSL/Paths/FixedIndexTypePathDescriptor.cs |  6 ++---
 src/Nest/DSL/Paths/IndexNamePathDescriptor.cs |  3 ++-
 .../DSL/Paths/IndexOptionalPathDescriptor.cs  |  3 ++-
 src/Nest/DSL/Paths/IndexPathDescriptor.cs     |  3 ++-
 src/Nest/DSL/Paths/IndexTypePathDescriptor.cs |  3 ++-
 .../DSL/Paths/IndexTypePathTypedDescriptor.cs |  3 ++-
 ...ndicesOptionalExplicitAllPathDescriptor.cs |  3 ++-
 .../Paths/IndicesOptionalPathDescriptor.cs    |  3 ++-
 .../IndicesOptionalTypesNamePathDecriptor.cs  |  3 ++-
 .../DSL/Paths/IndicesTypePathDescriptor.cs    |  3 ++-
 src/Nest/DSL/Paths/NamePathDescriptor.cs      |  3 ++-
 .../DSL/Paths/NodeIdOptionalDescriptor.cs     |  3 ++-
 src/Nest/DSL/Paths/QueryPathDescriptor.cs     |  3 ++-
 src/Nest/Nest.csproj                          |  1 +
 .../Profiling.InMemoryConnection/Program.cs   | 15 +++++++++++++
 19 files changed, 74 insertions(+), 18 deletions(-)
 create mode 100644 src/Nest/DSL/Paths/BasePathDescriptor.cs

diff --git a/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
index 6515e6aed7d..98e81fcd402 100644
--- a/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
+++ b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
@@ -21,7 +21,12 @@ public T Add(string name, object value)
 			return (T)this;
 		}
 
-		public T RequestConfiguration(IRequestConfiguration requestConfiguration)
+		public T RequestConfiguration(Func<RequestConfiguration, IRequestConfiguration> selector)
+		{
+			selector.ThrowIfNull("selector");
+			this._RequestConfiguration = selector(new RequestConfiguration());
+			return (T)this;
+		}public T RequestConfiguration(IRequestConfiguration requestConfiguration)
 		{
 			this._RequestConfiguration = requestConfiguration;
 			return (T)this;
diff --git a/src/Nest/DSL/BulkDescriptor.cs b/src/Nest/DSL/BulkDescriptor.cs
index 0ff70aa331b..0d5dab0b0f2 100644
--- a/src/Nest/DSL/BulkDescriptor.cs
+++ b/src/Nest/DSL/BulkDescriptor.cs
@@ -130,7 +130,7 @@ public BulkDescriptor Update<T, K>(Func<BulkUpdateDescriptor<T, K>, BulkUpdateDe
 
 		ElasticsearchPathInfo<BulkRequestParameters> IPathInfo<BulkRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = this.ToPathInfo<BulkRequestParameters>(settings, this._QueryString);
+			var pathInfo = this.ToPathInfo(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			return pathInfo;
 		}
diff --git a/src/Nest/DSL/Paths/BasePathDescriptor.cs b/src/Nest/DSL/Paths/BasePathDescriptor.cs
new file mode 100644
index 00000000000..815420c382b
--- /dev/null
+++ b/src/Nest/DSL/Paths/BasePathDescriptor.cs
@@ -0,0 +1,22 @@
+using System;
+using Elasticsearch.Net;
+using Elasticsearch.Net.Connection;
+
+namespace Nest
+{
+	public class BasePathDescriptor<T>
+		where T : BasePathDescriptor<T>
+	{
+		internal IRequestConfiguration _RequestConfiguration { get; set; }
+
+		/// <summary>
+		/// Specify settings for this request alone, handy if you need a custom timeout or want to bypass sniffing, retries
+		/// </summary>
+		public T RequestConfiguration(Func<RequestConfiguration, IRequestConfiguration> configurationSelector)
+		{
+			configurationSelector.ThrowIfNull("configurationSelector");
+			this._RequestConfiguration = configurationSelector(new RequestConfiguration());
+			return (T)this;
+		}
+	}
+}
\ No newline at end of file
diff --git a/src/Nest/DSL/Paths/DocumentPathDescriptor.cs b/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
index b78bec29f0c..2a8cb155989 100644
--- a/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// if one of the parameters is not explicitly specified this will fall back to the defaults for type <para>T</para>
 	/// </summary>
-	public class DocumentPathDescriptorBase<P, T, K>
+	public class DocumentPathDescriptorBase<P, T, K> : BasePathDescriptor<P>
 		where P : DocumentPathDescriptorBase<P, T, K>, new()
 		where T : class
 		where K : FluentRequestParameters<K>, new()
@@ -90,6 +90,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Id = id
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs b/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
index 0b3e57122f9..c890e219895 100644
--- a/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
@@ -19,7 +19,7 @@ namespace Nest
 	/// {index} is optional and so is {type} and will NOT fallback to the defaults of <para>T</para>
 	/// type can only be specified in conjuction with index.
 	/// </summary>
-	public class FixedIndexTypePathDescriptor<P, K> 
+	public class FixedIndexTypePathDescriptor<P, K> : BasePathDescriptor<P>
 		where P : FixedIndexTypePathDescriptor<P, K> 
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -53,8 +53,7 @@ public P FixedPath<TIndex,TType>()
 			return (P) this;
 		}
 		
-		internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValues settings, K queryString)
-			where K : FluentRequestParameters<K>, new()
+		internal virtual ElasticsearchPathInfo<K> ToPathInfo(IConnectionSettingsValues settings, K queryString)
 		{
 			var inferrer = new ElasticInferrer(settings);
 
@@ -67,6 +66,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Type = type
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs b/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
index 9315dcc9cf5..0c7b79e0a2e 100644
--- a/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// neither parameter is optional 
 	/// </summary>
-	public class IndexNamePathDescriptor<P, K> 
+	public class IndexNamePathDescriptor<P, K> : BasePathDescriptor<P>
 		where P : IndexNamePathDescriptor<P, K>, new()
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -62,6 +62,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Name = this._Name
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs b/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
index 8b21dff8bae..c13ae9f4089 100644
--- a/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// index is optional but AllIndices() needs to be explicitly specified for it to be optional
 	/// </summary>
-	public class IndexOptionalPathDescriptorBase<P, K> 
+	public class IndexOptionalPathDescriptorBase<P, K> : BasePathDescriptor<P>
 		where P : IndexOptionalPathDescriptorBase<P, K>, new()
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -66,6 +66,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexPathDescriptor.cs b/src/Nest/DSL/Paths/IndexPathDescriptor.cs
index 1aeb5ccba73..d2663e49bf9 100644
--- a/src/Nest/DSL/Paths/IndexPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexPathDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// index is not optional 
 	/// </summary>
-	public class IndexPathDescriptorBase<P, K> 
+	public class IndexPathDescriptorBase<P, K> : BasePathDescriptor<P> 
 		where P : IndexPathDescriptorBase<P, K>, new()
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -54,6 +54,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs b/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
index c64434b9080..c9e2c096339 100644
--- a/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
@@ -19,7 +19,7 @@ namespace Nest
 	/// </pre>
 	/// Where neither parameter is optional
 	/// </summary>
-	public class IndexTypePathDescriptor<P, K> 
+	public class IndexTypePathDescriptor<P, K> : BasePathDescriptor<P>
 		where P : IndexTypePathDescriptor<P, K>, new()
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -79,6 +79,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Type = type
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs b/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
index 02d1fffb630..f2251d6f5cc 100644
--- a/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// if one of the parameters is not explicitly specified this will fall back to the defaults for type <para>T</para>
 	/// </summary>
-	public class IndexTypePathTypedDescriptor<P, K, T> 
+	public class IndexTypePathTypedDescriptor<P, K, T> : BasePathDescriptor<P>
 		where P : IndexTypePathTypedDescriptor<P, K, T>, new()
 		where K : FluentRequestParameters<K>, new()
 		where T : class
@@ -79,6 +79,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Type = type
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
index 5104607b4d3..5db07450e2d 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
@@ -19,7 +19,7 @@ namespace Nest
 	/// </pre>
 	/// {indices} is optional but AllIndices() needs to be explicitly called.
 	/// </summary>
-	public class IndicesOptionalExplicitAllPathDescriptor<P, K> 
+	public class IndicesOptionalExplicitAllPathDescriptor<P, K> : BasePathDescriptor<P>
 		where P : IndicesOptionalExplicitAllPathDescriptor<P, K>, new()
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -71,6 +71,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
index 9296b7e3612..de0a4cfd7b9 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// {indices} is optional 
 	/// </summary>
-	public class IndicesOptionalPathDescriptor<P, K> 
+	public class IndicesOptionalPathDescriptor<P, K> : BasePathDescriptor<P>
 		where P : IndicesOptionalPathDescriptor<P, K>, new()
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -56,6 +56,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
index 733519f3874..94e1caf69aa 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
@@ -20,7 +20,7 @@ namespace Nest
 	/// </pre>
 	/// {types} is optional, {indices} is too but needs an explicit AllIndices().
 	/// </summary>
-	public class IndicesOptionalTypesNamePathDecriptor<P, K>
+	public class IndicesOptionalTypesNamePathDecriptor<P, K> : BasePathDescriptor<P>
 		where P : IndicesOptionalTypesNamePathDecriptor<P, K>, new()
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -140,6 +140,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Name = this._Name
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs b/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
index 5baa2ace0bb..dcd4ce601d1 100644
--- a/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// {indices} is optional and so is {type} and will fallback to default of <para>T</para>
 	/// </summary>
-	public class IndicesTypePathDescriptor<P, K, T> 
+	public class IndicesTypePathDescriptor<P, K, T> : BasePathDescriptor<P>
 		where P : IndicesTypePathDescriptor<P, K, T> 
 		where K : FluentRequestParameters<K>, new()
 		where T : class
@@ -90,6 +90,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Type = type
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/NamePathDescriptor.cs b/src/Nest/DSL/Paths/NamePathDescriptor.cs
index 307f552c9bf..5d6983d520b 100644
--- a/src/Nest/DSL/Paths/NamePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/NamePathDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// name is mandatory.
 	/// </summary>
-	public class NamePathDescriptor<P, K>
+	public class NamePathDescriptor<P, K> : BasePathDescriptor<P>
 		where P : NamePathDescriptor<P, K> 
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -44,6 +44,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Name = this._Name
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs b/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
index 1b451ba0eef..9e365586af6 100644
--- a/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
+++ b/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// node id is optional
 	/// </summary>
-	public class NodeIdOptionalDescriptor<P, K>
+	public class NodeIdOptionalDescriptor<P, K> : BasePathDescriptor<P>
 		where P : NodeIdOptionalDescriptor<P, K> 
 		where K : FluentRequestParameters<K>, new()
 	{
@@ -41,6 +41,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				NodeId = this._NodeId
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/QueryPathDescriptor.cs b/src/Nest/DSL/Paths/QueryPathDescriptor.cs
index d09f62b6dfd..c4363b02698 100644
--- a/src/Nest/DSL/Paths/QueryPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/QueryPathDescriptor.cs
@@ -18,7 +18,7 @@ namespace Nest
 	/// </pre>
 	/// all parameters are optional and will default to the defaults for <para>T</para>
 	/// </summary>
-	public class QueryPathDescriptorBase<P, T, K>
+	public class QueryPathDescriptorBase<P, T, K> : BasePathDescriptor<P>
 		where P : QueryPathDescriptorBase<P, T, K>, new()
 		where T : class
 		where K : FluentRequestParameters<K>, new()
@@ -139,6 +139,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 
 
 			pathInfo.RequestParameters = queryString ?? new K();
+			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/Nest.csproj b/src/Nest/Nest.csproj
index 8cb35b5359b..8f4e13c884e 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -163,6 +163,7 @@
     <Compile Include="DSL\ClearCacheDescriptor.cs" />
     <Compile Include="DSL\Facets\Ip4Range.cs" />
     <Compile Include="DSL\Facets\DateExpressionRange.cs" />
+    <Compile Include="DSL\Paths\BasePathDescriptor.cs" />
     <Compile Include="DSL\SourceDescriptor.cs" />
     <Compile Include="DSL\NodesStatsDescriptor.cs" />
     <Compile Include="DSL\NodesInfoDescriptor.cs" />
diff --git a/src/Profiling/Profiling.InMemoryConnection/Program.cs b/src/Profiling/Profiling.InMemoryConnection/Program.cs
index cdf589b8461..3e661ea89a9 100644
--- a/src/Profiling/Profiling.InMemoryConnection/Program.cs
+++ b/src/Profiling/Profiling.InMemoryConnection/Program.cs
@@ -1,4 +1,5 @@
 using System;
+using Elasticsearch.Net.Connection;
 using Nest;
 using Elasticsearch.Net;
 
@@ -27,6 +28,20 @@ static void Main(string[] args)
 				for (int i = calls; i > 0; i--)
 				{
 					client.Index(new Doc() {Id = "asdasd" + i, Name = "Name"});
+					
+					client.Bulk(b=>b
+						.
+					)
+
+					client.Raw.Bulk("fixed-index","fixed-type", r=>r
+						.Refresh(true)
+						.Consistency(ConsistencyOptions.All)
+						.RequestConfiguration(c=>c
+							.ConnectTimeout(50)
+							.RequestTimeout(50)
+							.DisableSniffing()
+						)
+					)
 				}
 			}
 			Console.WriteLine("done");

From 6baad444393cd1588e89715d4603e20fcf80ca49 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 12:28:25 +0200
Subject: [PATCH 10/20] added some more request settings

---
 .../Connection/IRequestConfiguration.cs       | 42 ++++++++++++++++++-
 src/Nest/DSL/MultiGetDescriptor.cs            |  2 +-
 src/Nest/DSL/MultiSearchDescriptor.cs         |  2 +-
 .../Profiling.InMemoryConnection/Program.cs   | 14 -------
 4 files changed, 42 insertions(+), 18 deletions(-)

diff --git a/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs b/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
index 82247dfd404..5c929a9d062 100644
--- a/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
+++ b/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
@@ -13,7 +13,7 @@ public interface IRequestConfiguration : IRequestConnectionConfiguration
 		/// <summary>
 		/// This will force the operation on the specified node, this will bypass any configured connection pool and will no retry.
 		/// </summary>
-		Uri ForceNode { get; }
+		Uri ForcedNode { get; }
 
 		/// <summary>
 		/// Forces no sniffing to occur on the request no matter what configuration is in place 
@@ -21,6 +21,10 @@ public interface IRequestConfiguration : IRequestConnectionConfiguration
 		/// </summary>
 		bool? SniffingDisabled { get; }
 
+		bool? PingDisabled { get; }
+
+		string AcceptsContentType { get; }
+
 	}
 
 	public class RequestConfiguration : RequestConfiguration<RequestConfiguration>, IRequestConfiguration
@@ -36,13 +40,15 @@ public class RequestConfiguration<T> : RequestConnectionConfiguration<T>, IReque
 		private int? _maxRetries;
 		private Uri _forceNode;
 		private bool? _sniffingDisabled;
+		private bool? _pingDisabled;
+		private string _acceptsContentType;
 
 		int? IRequestConfiguration.MaxRetries
 		{
 			get { return _maxRetries; }
 		}
 
-		Uri IRequestConfiguration.ForceNode
+		Uri IRequestConfiguration.ForcedNode
 		{
 			get { return _forceNode; }
 		}
@@ -52,11 +58,43 @@ Uri IRequestConfiguration.ForceNode
 			get { return _sniffingDisabled; }
 		}
 
+		public bool? PingDisabled
+		{
+			get { return _pingDisabled; }
+		}
+
+		public string AcceptsContentType
+		{
+			get { return _acceptsContentType; }
+		}
+
 		public T DisableSniffing(bool? disable = true)
 		{
 			this._sniffingDisabled = disable;
 			return (T)this;
+		}
+
+		public T DisablePing(bool? disable = true)
+		{
+			this._pingDisabled = disable;
+			return (T)this;
+		}
 
+		public T ForceNode(Uri uri)
+		{
+			this._forceNode = uri;
+			return (T)this;
+		}
+		public T Retry(int retry)
+		{
+			this._maxRetries = retry;
+			return (T)this;
+		}
+		
+		public T ContentType(string accepts)
+		{
+			this._acceptsContentType = accepts;
+			return (T)this;
 		}
 	}
 }
\ No newline at end of file
diff --git a/src/Nest/DSL/MultiGetDescriptor.cs b/src/Nest/DSL/MultiGetDescriptor.cs
index 03b75f50477..9b640b4203a 100644
--- a/src/Nest/DSL/MultiGetDescriptor.cs
+++ b/src/Nest/DSL/MultiGetDescriptor.cs
@@ -71,7 +71,7 @@ public MultiGetDescriptor GetMany<K>(IEnumerable<string> ids, Func<SimpleGetDesc
 		}
 		ElasticsearchPathInfo<MultiGetRequestParameters> IPathInfo<MultiGetRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = this.ToPathInfo<MultiGetRequestParameters>(settings, this._QueryString);
+			var pathInfo = this.ToPathInfo(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST; // no data in GETS in the .net world
 			return pathInfo;
 		}
diff --git a/src/Nest/DSL/MultiSearchDescriptor.cs b/src/Nest/DSL/MultiSearchDescriptor.cs
index efc30fd525d..8d728cdc4e6 100644
--- a/src/Nest/DSL/MultiSearchDescriptor.cs
+++ b/src/Nest/DSL/MultiSearchDescriptor.cs
@@ -38,7 +38,7 @@ public MultiSearchDescriptor Search<T>(Func<SearchDescriptor<T>, SearchDescripto
 
 		ElasticsearchPathInfo<MultiSearchRequestParameters> IPathInfo<MultiSearchRequestParameters>.ToPathInfo(IConnectionSettingsValues settings)
 		{
-			var pathInfo = base.ToPathInfo<MultiSearchRequestParameters>(settings, this._QueryString);
+			var pathInfo = base.ToPathInfo(settings, this._QueryString);
 			pathInfo.HttpMethod = PathInfoHttpMethod.POST;
 			return pathInfo;
 		}
diff --git a/src/Profiling/Profiling.InMemoryConnection/Program.cs b/src/Profiling/Profiling.InMemoryConnection/Program.cs
index 3e661ea89a9..d74bda0b031 100644
--- a/src/Profiling/Profiling.InMemoryConnection/Program.cs
+++ b/src/Profiling/Profiling.InMemoryConnection/Program.cs
@@ -28,20 +28,6 @@ static void Main(string[] args)
 				for (int i = calls; i > 0; i--)
 				{
 					client.Index(new Doc() {Id = "asdasd" + i, Name = "Name"});
-					
-					client.Bulk(b=>b
-						.
-					)
-
-					client.Raw.Bulk("fixed-index","fixed-type", r=>r
-						.Refresh(true)
-						.Consistency(ConsistencyOptions.All)
-						.RequestConfiguration(c=>c
-							.ConnectTimeout(50)
-							.RequestTimeout(50)
-							.DisableSniffing()
-						)
-					)
 				}
 			}
 			Console.WriteLine("done");

From 05f434e3be9b31ce7f6604f53a4b74f86d64be07 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 12:32:10 +0200
Subject: [PATCH 11/20] implemented forced node so that you can force a
 specific node to be hit no matter what the iconnectionpool will say

---
 src/Elasticsearch.Net/Connection/Transport.cs | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index b605fc8c39b..f74429921ea 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -170,7 +170,7 @@ private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestSt
 			IElasticsearchResponse response = null;
 
 			int initialSeed; bool shouldPingHint;
-			var baseUri = this._connectionPool.GetNext(requestState.Seed, out initialSeed, out shouldPingHint);
+			var baseUri = GetNextBaseUri(requestState, out initialSeed, out shouldPingHint);
 			requestState.Seed = initialSeed;
 
 			var uri = CreateUriToPath(baseUri, requestState.Path);
@@ -207,6 +207,18 @@ private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestSt
 			return RetryRequest<T>(requestState, uri, retried);
 		}
 
+		private Uri GetNextBaseUri<T>(TransportRequestState<T> requestState, out int initialSeed, out bool shouldPingHint)
+		{
+			if (requestState.RequestConfiguration != null && requestState.RequestConfiguration.ForcedNode != null)
+			{
+				initialSeed = 0; 
+				shouldPingHint = false;
+				return requestState.RequestConfiguration.ForcedNode;
+			}
+			var baseUri = this._connectionPool.GetNext(requestState.Seed, out initialSeed, out shouldPingHint);
+			return baseUri;
+		}
+
 		private ElasticsearchResponse<T> RetryRequest<T>(TransportRequestState<T> requestState, Uri baseUri, int retried, Exception e = null)
 		{
 			var maxRetries = this.GetMaximumRetries();
@@ -268,7 +280,7 @@ private Task<ElasticsearchResponse<T>> DoRequestAsync<T>(TransportRequestState<T
 			SniffIfInformationIsTooOld(retried);
 		
 			int initialSeed; bool shouldPingHint;
-			var baseUri = this._connectionPool.GetNext(requestState.Seed, out initialSeed, out shouldPingHint);
+			var baseUri = this.GetNextBaseUri(requestState, out initialSeed, out shouldPingHint);
 			requestState.Seed = initialSeed;
 
 			var uri = CreateUriToPath(baseUri, requestState.Path);

From 3e27430c0ee2e4c5e2a74ac296d3dfeab2d065a3 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 12:36:31 +0200
Subject: [PATCH 12/20] max retry can now be set per request

---
 src/Elasticsearch.Net/Connection/Transport.cs | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index f74429921ea..26981aa96cc 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -134,8 +134,13 @@ private void SniffIfInformationIsTooOld(int retried)
 		/// <summary>
 		/// Returns either the fixed maximum set on the connection configuration settings or the number of nodes
 		/// </summary>
-		private int GetMaximumRetries()
+		/// <param name="requestState"></param>
+		private int GetMaximumRetries(IRequestConfiguration requestConfiguration)
 		{
+			//if we have a request specific max retry setting use that
+			if (requestConfiguration.MaxRetries.HasValue)
+				return requestConfiguration.MaxRetries.Value;
+
 			return this._configurationValues.MaxRetries.GetValueOrDefault(this._connectionPool.MaxRetries);
 		}
 
@@ -192,7 +197,7 @@ private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestSt
 			}
 			catch (Exception e)
 			{
-				var maxRetries = this.GetMaximumRetries();
+				var maxRetries = this.GetMaximumRetries(requestState.RequestConfiguration);
 				if (maxRetries == 0 && retried == 0)
 					throw;
 				seenError = true;
@@ -221,7 +226,7 @@ private Uri GetNextBaseUri<T>(TransportRequestState<T> requestState, out int ini
 
 		private ElasticsearchResponse<T> RetryRequest<T>(TransportRequestState<T> requestState, Uri baseUri, int retried, Exception e = null)
 		{
-			var maxRetries = this.GetMaximumRetries();
+			var maxRetries = this.GetMaximumRetries(requestState.RequestConfiguration);
 			var exceptionMessage = MaxRetryExceptionMessage.F(requestState.Method, requestState.Path.IsNullOrEmpty() ? "/" : "", retried);
 
 			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);
@@ -323,7 +328,7 @@ private Task<ElasticsearchResponse<T>>  _doRequestAsyncOrRetry<T>(
 
 		private Task<ElasticsearchResponse<T>> RetryRequestAsync<T>(TransportRequestState<T> requestState, Uri baseUri, int retried, Exception e = null)
 		{
-			var maxRetries = this.GetMaximumRetries();
+			var maxRetries = this.GetMaximumRetries(requestState.RequestConfiguration);
 			var exceptionMessage = MaxRetryExceptionMessage.F(requestState.Method, requestState.Path, retried);
 
 			this._connectionPool.MarkDead(baseUri, this._configurationValues.DeadTimeout, this._configurationValues.MaxDeadTimeout);

From 6b5eb340f5e627b42e5d8b9a532612abdb46acaf Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 12:39:33 +0200
Subject: [PATCH 13/20] ping can now also be disabled per request

---
 src/Elasticsearch.Net/Connection/Transport.cs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index 26981aa96cc..bf21a8888ac 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -183,7 +183,11 @@ private ElasticsearchResponse<T> DoRequest<T>(TransportRequestState<T> requestSt
 			
 			try
 			{
-				if (shouldPingHint && !this._configurationValues.DisablePings)
+				if (shouldPingHint 
+					&& !this._configurationValues.DisablePings
+					&& (requestState.RequestConfiguration == null
+						|| !requestState.RequestConfiguration.PingDisabled.GetValueOrDefault(false))
+					)
 					this.Ping(baseUri);
 
 				var streamResponse = _doRequest(requestState.Method, uri, requestState.PostData, requestState.RequestConfiguration);

From 47898e01437cebf43cb07770e67042d099967784 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 12:44:00 +0200
Subject: [PATCH 14/20] moved accepts content type to IRequestConnectioSettings

---
 .../Connection/IRequestConfiguration.cs            |  8 +-------
 .../Connection/IRequestConnectionConfiguration.cs  | 14 +++++++++++++-
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs b/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
index 5c929a9d062..675f7eaab2f 100644
--- a/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
+++ b/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
@@ -23,7 +23,6 @@ public interface IRequestConfiguration : IRequestConnectionConfiguration
 
 		bool? PingDisabled { get; }
 
-		string AcceptsContentType { get; }
 
 	}
 
@@ -41,7 +40,6 @@ public class RequestConfiguration<T> : RequestConnectionConfiguration<T>, IReque
 		private Uri _forceNode;
 		private bool? _sniffingDisabled;
 		private bool? _pingDisabled;
-		private string _acceptsContentType;
 
 		int? IRequestConfiguration.MaxRetries
 		{
@@ -91,10 +89,6 @@ public T Retry(int retry)
 			return (T)this;
 		}
 		
-		public T ContentType(string accepts)
-		{
-			this._acceptsContentType = accepts;
-			return (T)this;
-		}
+		
 	}
 }
\ No newline at end of file
diff --git a/src/Elasticsearch.Net/Connection/IRequestConnectionConfiguration.cs b/src/Elasticsearch.Net/Connection/IRequestConnectionConfiguration.cs
index bb2e57374cf..f084d2501b9 100644
--- a/src/Elasticsearch.Net/Connection/IRequestConnectionConfiguration.cs
+++ b/src/Elasticsearch.Net/Connection/IRequestConnectionConfiguration.cs
@@ -6,6 +6,7 @@ public interface IRequestConnectionConfiguration
 	{
 		int? TimeoutRequest { get; }
 		int? TimeoutConnect { get; }
+		string AcceptsContentType { get; }
 	}
 	
 
@@ -30,17 +31,28 @@ public class RequestConnectionConfiguration<T> : IRequestConnectionConfiguration
 		{
 			get { return _timeoutConnection; }
 		}
+		private string _acceptsContentType;
+		public string AcceptsContentType
+		{
+			get { return _acceptsContentType; }
+		}
 
 		public T RequestTimeout(int request)
 		{
 			this._timeoutRequest = request;
 			return (T)this;
 		}
+
 		public T ConnectTimeout(int request)
 		{
 			this._timeoutConnection = request;
 			return (T)this;
+		}		
+		
+		public T ContentType(string accepts)
+		{
+			this._acceptsContentType = accepts;
+			return (T)this;
 		}
-
 	}
 }
\ No newline at end of file

From 0ab50789226350cff155dacccb9ef51fc4f2dbf7 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 13:47:36 +0200
Subject: [PATCH 15/20] Cat endpoints are now generated with a text/plain
 request settings and different default return type, fixes failing _cat yaml
 tests

---
 .../Domain/ApiEndpoint.cs                     |   12 +-
 .../Domain/CsharpMethod.cs                    |    1 +
 .../ElasticsearchClient.Generated.cshtml      |   11 +-
 .../Connection/HttpConnection.cs              |   32 +-
 .../Connection/IRequestConfiguration.cs       |    4 -
 src/Elasticsearch.Net/Connection/Transport.cs |    2 +-
 .../Domain/BaseRequestParameters.cs           |    2 +-
 .../Domain/FluentRequestParameters.cs         |    9 +-
 .../ElasticsearchClient.Generated.cs          | 1344 ++++++++++++++---
 .../IElasticsearchClient.Generated.cs         |   72 +-
 src/Nest/DSL/Paths/BasePathDescriptor.cs      |    4 +-
 src/Nest/DSL/Paths/DocumentPathDescriptor.cs  |    2 +-
 .../DSL/Paths/FixedIndexTypePathDescriptor.cs |    2 +-
 src/Nest/DSL/Paths/IndexNamePathDescriptor.cs |    2 +-
 .../DSL/Paths/IndexOptionalPathDescriptor.cs  |    2 +-
 src/Nest/DSL/Paths/IndexPathDescriptor.cs     |    2 +-
 src/Nest/DSL/Paths/IndexTypePathDescriptor.cs |    2 +-
 .../DSL/Paths/IndexTypePathTypedDescriptor.cs |    2 +-
 ...ndicesOptionalExplicitAllPathDescriptor.cs |    2 +-
 .../Paths/IndicesOptionalPathDescriptor.cs    |    2 +-
 .../IndicesOptionalTypesNamePathDecriptor.cs  |    2 +-
 .../DSL/Paths/IndicesTypePathDescriptor.cs    |    2 +-
 src/Nest/DSL/Paths/NamePathDescriptor.cs      |    2 +-
 .../DSL/Paths/NodeIdOptionalDescriptor.cs     |    2 +-
 src/Nest/DSL/Paths/QueryPathDescriptor.cs     |    2 +-
 .../YamlTestsBase.cs                          |   12 +-
 .../Core/Domain/Connection/ConnectionTests.cs |    2 +-
 27 files changed, 1267 insertions(+), 268 deletions(-)

diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs b/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs
index 336d9722c3a..5de2a82bdf7 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/ApiEndpoint.cs
@@ -156,6 +156,7 @@ public IEnumerable<CsharpMethod> CsharpMethods
 							QueryStringParamName = queryStringParamName,
 							ReturnType = "ElasticsearchResponse<T>",
 							ReturnTypeGeneric = "<T>",
+							CallTypeGeneric = "T",
 							ReturnDescription = 
 								"ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T."
 								+ explanationOfT,
@@ -180,6 +181,7 @@ public IEnumerable<CsharpMethod> CsharpMethods
 							QueryStringParamName = queryStringParamName,
 							ReturnType = "Task<ElasticsearchResponse<T>>",
 							ReturnTypeGeneric = "<T>",
+							CallTypeGeneric = "T",
 							ReturnDescription = 
 								"A task that'll return an ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T."
 								+ explanationOfT,
@@ -204,11 +206,15 @@ public IEnumerable<CsharpMethod> CsharpMethods
 							+ paraIndent + 
 								"<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>";
 
+						var defaultBoundGeneric = Url.Path.Contains("_cat") ? "string" : "DynamicDictionary";
+
 						apiMethod = new CsharpMethod
 						{
 							QueryStringParamName = queryStringParamName,
-							ReturnType = "ElasticsearchResponse<DynamicDictionary>",
+							ReturnType = string.Format("ElasticsearchResponse<{0}>", defaultBoundGeneric),
 							ReturnTypeGeneric = null,
+							CallTypeGeneric = defaultBoundGeneric == "DynamicDictionary" 
+								? "Dictionary<string, object>" : defaultBoundGeneric,
 							ReturnDescription = 
 								"ElasticsearchResponse&lt;T&gt; holding the response body deserialized as DynamicDictionary"
 								+ explanationOfDynamic,
@@ -226,8 +232,10 @@ public IEnumerable<CsharpMethod> CsharpMethods
 						apiMethod = new CsharpMethod
 						{
 							QueryStringParamName = queryStringParamName,
-							ReturnType = "Task<ElasticsearchResponse<DynamicDictionary>>",
+							ReturnType = string.Format("Task<ElasticsearchResponse<{0}>>", defaultBoundGeneric),
 							ReturnTypeGeneric = null,
+							CallTypeGeneric = defaultBoundGeneric == "DynamicDictionary" 
+								? "Dictionary<string, object>" : defaultBoundGeneric,
 							ReturnDescription = 
 								"Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary"
 								+ explanationOfDynamic,
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/CsharpMethod.cs b/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/CsharpMethod.cs
index 6247eeebae1..36d3e225fb2 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/CsharpMethod.cs
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Domain/CsharpMethod.cs
@@ -6,6 +6,7 @@ public class CsharpMethod
 	{
 		public string ReturnType { get; set; }
 		public string ReturnTypeGeneric { get; set; }
+		public string CallTypeGeneric { get; set; }
 		public string ReturnDescription { get; set; }
 		public string FullName { get; set; }
 		public string QueryStringParamName { get; set; }
diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/ElasticsearchClient.Generated.cshtml b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/ElasticsearchClient.Generated.cshtml
index 30adcc2c7ae..cb6dc364e80 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/ElasticsearchClient.Generated.cshtml
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/Views/ElasticsearchClient.Generated.cshtml
@@ -65,15 +65,20 @@ namespace Elasticsearch.Net
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new @(method.QueryStringParamName)());
+				requestParams = requestParameters(new @(method.QueryStringParamName)()@(url.StartsWith("_cat") ? Raw(".RequestConfiguration(r=>r.ContentType(\"text/plain\"))") : null));
 				ToNameValueCollection(requestParams);
 			}
+			@if (url.StartsWith("_cat"))
+			{
+<text>			else requestParams = new @(method.QueryStringParamName)().RequestConfiguration(r=>r.ContentType("text/plain")); </text>
+			}
+
 			@{
 			bool isAsync = method.ReturnType.StartsWith("Task<");
 			string requestMethod = isAsync ? "DoRequestAsync" : "DoRequest";
-			bool wrap = method.ReturnTypeGeneric == null;
+			bool wrap = method.CallTypeGeneric == "Dictionary<string, object>";
 		}
-			return @(wrap ? "ElasticsearchResponse.Wrap"+ (isAsync ? "Async" : "") +"("  : "")this.@(requestMethod)@(Raw(method.ReturnTypeGeneric ?? "<Dictionary<string, object>>"))(
+			return @(wrap ? "ElasticsearchResponse.Wrap"+ (isAsync ? "Async" : "") +"("  : "")this.@(requestMethod)@(Raw("<" + method.CallTypeGeneric + ">"))(
 				"@method.HttpMethod", url@(method.Parts.Any(pp=>pp.Name == "body") ? ", body" : ", data: null"), 
 				requestParameters: requestParams
 			)@(wrap ? ")" : "");
diff --git a/src/Elasticsearch.Net/Connection/HttpConnection.cs b/src/Elasticsearch.Net/Connection/HttpConnection.cs
index b920fded6b8..aee60b9d389 100644
--- a/src/Elasticsearch.Net/Connection/HttpConnection.cs
+++ b/src/Elasticsearch.Net/Connection/HttpConnection.cs
@@ -71,46 +71,46 @@ public virtual ElasticsearchResponse<Stream> DeleteSync(Uri uri, byte[] data, IR
 
 		private ElasticsearchResponse<Stream> HeaderOnlyRequest(Uri uri, string method, IRequestConnectionConfiguration requestSpecificConfig)
 		{
-			var r = this.CreateHttpWebRequest(uri, method);
+			var r = this.CreateHttpWebRequest(uri, method, requestSpecificConfig);
 			return this.DoSynchronousRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
 
 		private ElasticsearchResponse<Stream> BodyRequest(Uri uri, byte[] data, string method, IRequestConnectionConfiguration requestSpecificConfig)
 		{
-			var r = this.CreateHttpWebRequest(uri, method);
+			var r = this.CreateHttpWebRequest(uri, method, requestSpecificConfig);
 			return this.DoSynchronousRequest(r, data, requestSpecificConfig);
 		}
 
 		public virtual Task<ElasticsearchResponse<Stream>> Get(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
-			var r = this.CreateHttpWebRequest(uri, "GET");
+			var r = this.CreateHttpWebRequest(uri, "GET", requestSpecificConfig);
 			return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
 		public virtual Task<ElasticsearchResponse<Stream>> Head(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
-			var r = this.CreateHttpWebRequest(uri, "HEAD");
+			var r = this.CreateHttpWebRequest(uri, "HEAD", requestSpecificConfig);
 			return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
 		public virtual Task<ElasticsearchResponse<Stream>> Post(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
-			var r = this.CreateHttpWebRequest(uri, "POST");
+			var r = this.CreateHttpWebRequest(uri, "POST", requestSpecificConfig);
 			return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig);
 		}
 
 		public virtual Task<ElasticsearchResponse<Stream>> Put(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
-			var r = this.CreateHttpWebRequest(uri, "PUT");
+			var r = this.CreateHttpWebRequest(uri, "PUT", requestSpecificConfig);
 			return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig);
 		}
 
 		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, byte[] data, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
-			var r = this.CreateHttpWebRequest(uri, "DELETE");
+			var r = this.CreateHttpWebRequest(uri, "DELETE", requestSpecificConfig);
 			return this.DoAsyncRequest(r, data, requestSpecificConfig: requestSpecificConfig);
 		}
 		public virtual Task<ElasticsearchResponse<Stream>> Delete(Uri uri, IRequestConnectionConfiguration requestSpecificConfig = null)
 		{
-			var r = this.CreateHttpWebRequest(uri, "DELETE");
+			var r = this.CreateHttpWebRequest(uri, "DELETE", requestSpecificConfig);
 			return this.DoAsyncRequest(r, requestSpecificConfig: requestSpecificConfig);
 		}
 
@@ -127,9 +127,9 @@ private static void ThreadTimeoutCallback(object state, bool timedOut)
 		}
 
 
-		protected virtual HttpWebRequest CreateHttpWebRequest(Uri uri, string method)
+		protected virtual HttpWebRequest CreateHttpWebRequest(Uri uri, string method, IRequestConnectionConfiguration requestSpecificConfig)
 		{
-			var myReq = this.CreateWebRequest(uri, method);
+			var myReq = this.CreateWebRequest(uri, method, requestSpecificConfig);
 			this.SetBasicAuthorizationIfNeeded(myReq);
 			this.SetProxyIfNeeded(myReq);
 			return myReq;
@@ -160,17 +160,19 @@ private void SetBasicAuthorizationIfNeeded(HttpWebRequest myReq)
 			//}
 		}
 
-		protected virtual HttpWebRequest CreateWebRequest(Uri uri, string method)
+		protected virtual HttpWebRequest CreateWebRequest(Uri uri, string method, IRequestConnectionConfiguration requestSpecificConfig)
 		{
 			//TODO append global querystring
 			//var url = this._CreateUriString(path);
 
 			var myReq = (HttpWebRequest)WebRequest.Create(uri);
-			//TODO move this to transport
-			if (!uri.AbsolutePath.StartsWith("_cat"))
+
+			myReq.Accept = "application/json";
+			myReq.ContentType = "application/json";
+			if (requestSpecificConfig != null && !string.IsNullOrWhiteSpace(requestSpecificConfig.AcceptsContentType))
 			{
-				myReq.Accept = "application/json";
-				myReq.ContentType = "application/json";
+				myReq.Accept = requestSpecificConfig.AcceptsContentType;
+				myReq.ContentType = requestSpecificConfig.AcceptsContentType;
 			}
 			var timeout = this._ConnectionSettings.Timeout;
 			myReq.Timeout = timeout; // 1 minute timeout.
diff --git a/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs b/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
index 675f7eaab2f..e348349d303 100644
--- a/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
+++ b/src/Elasticsearch.Net/Connection/IRequestConfiguration.cs
@@ -61,10 +61,6 @@ public bool? PingDisabled
 			get { return _pingDisabled; }
 		}
 
-		public string AcceptsContentType
-		{
-			get { return _acceptsContentType; }
-		}
 
 		public T DisableSniffing(bool? disable = true)
 		{
diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index bf21a8888ac..904eaa3e505 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -90,7 +90,7 @@ public IList<Uri> Sniff()
 				.RequestTimeout(pingTimeout)
 				.DisableSniffing();
 			var requestParameters = new FluentRequestParameters()
-				.RequestConfiguration(requestOverrides);
+				.RequestConfiguration(r => requestOverrides);
 			
 			var path = "_nodes/_all/clear?timeout=" + pingTimeout;
 
diff --git a/src/Elasticsearch.Net/Domain/BaseRequestParameters.cs b/src/Elasticsearch.Net/Domain/BaseRequestParameters.cs
index a64384db6a2..44ba709d6f6 100644
--- a/src/Elasticsearch.Net/Domain/BaseRequestParameters.cs
+++ b/src/Elasticsearch.Net/Domain/BaseRequestParameters.cs
@@ -10,7 +10,7 @@ public abstract class BaseRequestParameters : IRequestParameters
 		
 		internal object _DeserializationState = null;
 
-		internal IRequestConfiguration _RequestConfiguration = null;
+		internal RequestConfiguration _RequestConfiguration = null;
 		internal NameValueCollection _queryString;
 
 		NameValueCollection IRequestParameters.QueryString { get { return _queryString;}  }
diff --git a/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
index 98e81fcd402..0d78161c98f 100644
--- a/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
+++ b/src/Elasticsearch.Net/Domain/FluentRequestParameters.cs
@@ -21,16 +21,13 @@ public T Add(string name, object value)
 			return (T)this;
 		}
 
-		public T RequestConfiguration(Func<RequestConfiguration, IRequestConfiguration> selector)
+		public T RequestConfiguration(Func<RequestConfiguration, RequestConfiguration> selector)
 		{
 			selector.ThrowIfNull("selector");
-			this._RequestConfiguration = selector(new RequestConfiguration());
-			return (T)this;
-		}public T RequestConfiguration(IRequestConfiguration requestConfiguration)
-		{
-			this._RequestConfiguration = requestConfiguration;
+			this._RequestConfiguration = selector(this._RequestConfiguration ?? new RequestConfiguration());
 			return (T)this;
 		}
+		
 		public T DeserializationState(object deserializationState)
 		{
 			_DeserializationState = deserializationState;
diff --git a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
index 402c17da3c5..7c42e426025 100644
--- a/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/ElasticsearchClient.Generated.cs
@@ -41,6 +41,7 @@ public ElasticsearchResponse<T> Bulk<T>(object body, Func<BulkRequestParameters,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -72,6 +73,7 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(object body, Func<BulkRequest
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -105,6 +107,7 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(object body, Func<BulkReque
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -138,6 +141,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(object body, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -171,6 +175,7 @@ public ElasticsearchResponse<T> Bulk<T>(string index, object body, Func<BulkRequ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -204,6 +209,7 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, object body, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -239,6 +245,7 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(string index, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -274,6 +281,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, ob
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -309,6 +317,7 @@ public ElasticsearchResponse<T> Bulk<T>(string index, string type, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -344,6 +353,7 @@ public Task<ElasticsearchResponse<T>> BulkAsync<T>(string index, string type, ob
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -381,6 +391,7 @@ public ElasticsearchResponse<DynamicDictionary> Bulk(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -418,6 +429,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkAsync(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -449,6 +461,7 @@ public ElasticsearchResponse<T> BulkPut<T>(object body, Func<BulkRequestParamete
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -480,6 +493,7 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(object body, Func<BulkRequ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -513,6 +527,7 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(object body, Func<BulkRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -546,6 +561,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -579,6 +595,7 @@ public ElasticsearchResponse<T> BulkPut<T>(string index, object body, Func<BulkR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -612,6 +629,7 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -647,6 +665,7 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, object bod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -682,6 +701,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -717,6 +737,7 @@ public ElasticsearchResponse<T> BulkPut<T>(string index, string type, object bod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -752,6 +773,7 @@ public Task<ElasticsearchResponse<T>> BulkPutAsync<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -789,6 +811,7 @@ public ElasticsearchResponse<DynamicDictionary> BulkPut(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -826,6 +849,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> BulkPutAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -852,9 +876,11 @@ public ElasticsearchResponse<T> CatAliases<T>(Func<CatAliasesRequestParameters,
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAliasesRequestParameters());
+				requestParams = requestParameters(new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -882,9 +908,11 @@ public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(Func<CatAliasesRequestP
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAliasesRequestParameters());
+				requestParams = requestParameters(new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -908,20 +936,22 @@ public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(Func<CatAliasesRequestP
 		///<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> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/aliases";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAliasesRequestParameters());
+				requestParams = requestParameters(new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/aliases
@@ -940,20 +970,22 @@ public ElasticsearchResponse<DynamicDictionary> CatAliases(Func<CatAliasesReques
 		///<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>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/aliases";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAliasesRequestParameters());
+				requestParams = requestParameters(new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
@@ -978,9 +1010,11 @@ public ElasticsearchResponse<T> CatAliases<T>(string name, Func<CatAliasesReques
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAliasesRequestParameters());
+				requestParams = requestParameters(new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -1010,9 +1044,11 @@ public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(string name, Func<CatAl
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAliasesRequestParameters());
+				requestParams = requestParameters(new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -1037,21 +1073,23 @@ public Task<ElasticsearchResponse<T>> CatAliasesAsync<T>(string name, Func<CatAl
 		///<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> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAliasesRequestParameters());
+				requestParams = requestParameters(new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
@@ -1071,21 +1109,23 @@ public ElasticsearchResponse<DynamicDictionary> CatAliases(string name, Func<Cat
 		///<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>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null)
 		{
 			name.ThrowIfNullOrEmpty("name");
 			var url = "_cat/aliases/{0}".F(Encoded(name));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAliasesRequestParameters());
+				requestParams = requestParameters(new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAliasesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/allocation
@@ -1108,9 +1148,11 @@ public ElasticsearchResponse<T> CatAllocation<T>(Func<CatAllocationRequestParame
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAllocationRequestParameters());
+				requestParams = requestParameters(new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -1138,9 +1180,11 @@ public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(Func<CatAllocationRe
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAllocationRequestParameters());
+				requestParams = requestParameters(new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -1164,20 +1208,22 @@ public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(Func<CatAllocationRe
 		///<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> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/allocation";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAllocationRequestParameters());
+				requestParams = requestParameters(new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/allocation
@@ -1196,20 +1242,22 @@ public ElasticsearchResponse<DynamicDictionary> CatAllocation(Func<CatAllocation
 		///<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>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/allocation";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAllocationRequestParameters());
+				requestParams = requestParameters(new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
@@ -1234,9 +1282,11 @@ public ElasticsearchResponse<T> CatAllocation<T>(string node_id, Func<CatAllocat
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAllocationRequestParameters());
+				requestParams = requestParameters(new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -1266,9 +1316,11 @@ public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(string node_id, Func
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAllocationRequestParameters());
+				requestParams = requestParameters(new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -1293,21 +1345,23 @@ public Task<ElasticsearchResponse<T>> CatAllocationAsync<T>(string node_id, Func
 		///<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> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAllocationRequestParameters());
+				requestParams = requestParameters(new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
@@ -1327,21 +1381,23 @@ public ElasticsearchResponse<DynamicDictionary> CatAllocation(string node_id, Fu
 		///<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>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null)
 		{
 			node_id.ThrowIfNullOrEmpty("node_id");
 			var url = "_cat/allocation/{0}".F(Encoded(node_id));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatAllocationRequestParameters());
+				requestParams = requestParameters(new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatAllocationRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/count
@@ -1364,9 +1420,11 @@ public ElasticsearchResponse<T> CatCount<T>(Func<CatCountRequestParameters, CatC
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatCountRequestParameters());
+				requestParams = requestParameters(new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -1394,9 +1452,11 @@ public Task<ElasticsearchResponse<T>> CatCountAsync<T>(Func<CatCountRequestParam
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatCountRequestParameters());
+				requestParams = requestParameters(new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -1420,20 +1480,22 @@ public Task<ElasticsearchResponse<T>> CatCountAsync<T>(Func<CatCountRequestParam
 		///<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> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/count";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatCountRequestParameters());
+				requestParams = requestParameters(new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/count
@@ -1452,20 +1514,22 @@ public ElasticsearchResponse<DynamicDictionary> CatCount(Func<CatCountRequestPar
 		///<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>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/count";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatCountRequestParameters());
+				requestParams = requestParameters(new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/count/{index}
@@ -1490,9 +1554,11 @@ public ElasticsearchResponse<T> CatCount<T>(string index, Func<CatCountRequestPa
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatCountRequestParameters());
+				requestParams = requestParameters(new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -1522,9 +1588,11 @@ public Task<ElasticsearchResponse<T>> CatCountAsync<T>(string index, Func<CatCou
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatCountRequestParameters());
+				requestParams = requestParameters(new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -1549,21 +1617,23 @@ public Task<ElasticsearchResponse<T>> CatCountAsync<T>(string index, Func<CatCou
 		///<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> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatCountRequestParameters());
+				requestParams = requestParameters(new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/count/{index}
@@ -1583,21 +1653,23 @@ public ElasticsearchResponse<DynamicDictionary> CatCount(string index, Func<CatC
 		///<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>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/count/{0}".F(Encoded(index));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatCountRequestParameters());
+				requestParams = requestParameters(new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatCountRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/health
@@ -1620,9 +1692,11 @@ public ElasticsearchResponse<T> CatHealth<T>(Func<CatHealthRequestParameters, Ca
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatHealthRequestParameters());
+				requestParams = requestParameters(new CatHealthRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatHealthRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -1650,9 +1724,11 @@ public Task<ElasticsearchResponse<T>> CatHealthAsync<T>(Func<CatHealthRequestPar
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatHealthRequestParameters());
+				requestParams = requestParameters(new CatHealthRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatHealthRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -1676,20 +1752,22 @@ public Task<ElasticsearchResponse<T>> CatHealthAsync<T>(Func<CatHealthRequestPar
 		///<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> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/health";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatHealthRequestParameters());
+				requestParams = requestParameters(new CatHealthRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatHealthRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/health
@@ -1708,20 +1786,22 @@ public ElasticsearchResponse<DynamicDictionary> CatHealth(Func<CatHealthRequestP
 		///<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>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/health";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatHealthRequestParameters());
+				requestParams = requestParameters(new CatHealthRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatHealthRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat
@@ -1744,9 +1824,11 @@ public ElasticsearchResponse<T> CatHelp<T>(Func<CatHelpRequestParameters, CatHel
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatHelpRequestParameters());
+				requestParams = requestParameters(new CatHelpRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatHelpRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -1774,9 +1856,11 @@ public Task<ElasticsearchResponse<T>> CatHelpAsync<T>(Func<CatHelpRequestParamet
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatHelpRequestParameters());
+				requestParams = requestParameters(new CatHelpRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatHelpRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -1800,20 +1884,22 @@ public Task<ElasticsearchResponse<T>> CatHelpAsync<T>(Func<CatHelpRequestParamet
 		///<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> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null)
 		{
 			var url = "_cat";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatHelpRequestParameters());
+				requestParams = requestParameters(new CatHelpRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatHelpRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat
@@ -1832,20 +1918,22 @@ public ElasticsearchResponse<DynamicDictionary> CatHelp(Func<CatHelpRequestParam
 		///<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>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null)
 		{
 			var url = "_cat";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatHelpRequestParameters());
+				requestParams = requestParameters(new CatHelpRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatHelpRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/indices
@@ -1868,9 +1956,11 @@ public ElasticsearchResponse<T> CatIndices<T>(Func<CatIndicesRequestParameters,
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatIndicesRequestParameters());
+				requestParams = requestParameters(new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -1898,9 +1988,11 @@ public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(Func<CatIndicesRequestP
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatIndicesRequestParameters());
+				requestParams = requestParameters(new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -1924,20 +2016,22 @@ public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(Func<CatIndicesRequestP
 		///<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> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/indices";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatIndicesRequestParameters());
+				requestParams = requestParameters(new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/indices
@@ -1956,20 +2050,22 @@ public ElasticsearchResponse<DynamicDictionary> CatIndices(Func<CatIndicesReques
 		///<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>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/indices";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatIndicesRequestParameters());
+				requestParams = requestParameters(new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
@@ -1994,9 +2090,11 @@ public ElasticsearchResponse<T> CatIndices<T>(string index, Func<CatIndicesReque
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatIndicesRequestParameters());
+				requestParams = requestParameters(new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -2026,9 +2124,11 @@ public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(string index, Func<CatI
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatIndicesRequestParameters());
+				requestParams = requestParameters(new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -2053,21 +2153,23 @@ public Task<ElasticsearchResponse<T>> CatIndicesAsync<T>(string index, Func<CatI
 		///<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> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatIndicesRequestParameters());
+				requestParams = requestParameters(new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
@@ -2087,21 +2189,23 @@ public ElasticsearchResponse<DynamicDictionary> CatIndices(string index, Func<Ca
 		///<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>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/indices/{0}".F(Encoded(index));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatIndicesRequestParameters());
+				requestParams = requestParameters(new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatIndicesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/master
@@ -2124,9 +2228,11 @@ public ElasticsearchResponse<T> CatMaster<T>(Func<CatMasterRequestParameters, Ca
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatMasterRequestParameters());
+				requestParams = requestParameters(new CatMasterRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatMasterRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -2154,9 +2260,11 @@ public Task<ElasticsearchResponse<T>> CatMasterAsync<T>(Func<CatMasterRequestPar
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatMasterRequestParameters());
+				requestParams = requestParameters(new CatMasterRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatMasterRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -2180,20 +2288,22 @@ public Task<ElasticsearchResponse<T>> CatMasterAsync<T>(Func<CatMasterRequestPar
 		///<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> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/master";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatMasterRequestParameters());
+				requestParams = requestParameters(new CatMasterRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatMasterRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/master
@@ -2212,20 +2322,22 @@ public ElasticsearchResponse<DynamicDictionary> CatMaster(Func<CatMasterRequestP
 		///<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>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/master";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatMasterRequestParameters());
+				requestParams = requestParameters(new CatMasterRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatMasterRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/nodes
@@ -2248,9 +2360,11 @@ public ElasticsearchResponse<T> CatNodes<T>(Func<CatNodesRequestParameters, CatN
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatNodesRequestParameters());
+				requestParams = requestParameters(new CatNodesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatNodesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -2278,9 +2392,11 @@ public Task<ElasticsearchResponse<T>> CatNodesAsync<T>(Func<CatNodesRequestParam
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatNodesRequestParameters());
+				requestParams = requestParameters(new CatNodesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatNodesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -2304,20 +2420,22 @@ public Task<ElasticsearchResponse<T>> CatNodesAsync<T>(Func<CatNodesRequestParam
 		///<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> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/nodes";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatNodesRequestParameters());
+				requestParams = requestParameters(new CatNodesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatNodesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/nodes
@@ -2336,20 +2454,22 @@ public ElasticsearchResponse<DynamicDictionary> CatNodes(Func<CatNodesRequestPar
 		///<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>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/nodes";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatNodesRequestParameters());
+				requestParams = requestParameters(new CatNodesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatNodesRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
@@ -2372,9 +2492,11 @@ public ElasticsearchResponse<T> CatPendingTasks<T>(Func<CatPendingTasksRequestPa
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatPendingTasksRequestParameters());
+				requestParams = requestParameters(new CatPendingTasksRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatPendingTasksRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -2402,9 +2524,11 @@ public Task<ElasticsearchResponse<T>> CatPendingTasksAsync<T>(Func<CatPendingTas
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatPendingTasksRequestParameters());
+				requestParams = requestParameters(new CatPendingTasksRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatPendingTasksRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -2428,20 +2552,22 @@ public Task<ElasticsearchResponse<T>> CatPendingTasksAsync<T>(Func<CatPendingTas
 		///<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> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/pending_tasks";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatPendingTasksRequestParameters());
+				requestParams = requestParameters(new CatPendingTasksRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatPendingTasksRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
@@ -2460,20 +2586,22 @@ public ElasticsearchResponse<DynamicDictionary> CatPendingTasks(Func<CatPendingT
 		///<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>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/pending_tasks";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatPendingTasksRequestParameters());
+				requestParams = requestParameters(new CatPendingTasksRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatPendingTasksRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/recovery
@@ -2496,9 +2624,11 @@ public ElasticsearchResponse<T> CatRecovery<T>(Func<CatRecoveryRequestParameters
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				requestParams = requestParameters(new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -2526,9 +2656,11 @@ public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(Func<CatRecoveryReques
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				requestParams = requestParameters(new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -2552,20 +2684,22 @@ public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(Func<CatRecoveryReques
 		///<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> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/recovery";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				requestParams = requestParameters(new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/recovery
@@ -2584,20 +2718,22 @@ public ElasticsearchResponse<DynamicDictionary> CatRecovery(Func<CatRecoveryRequ
 		///<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>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/recovery";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				requestParams = requestParameters(new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
@@ -2622,9 +2758,11 @@ public ElasticsearchResponse<T> CatRecovery<T>(string index, Func<CatRecoveryReq
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				requestParams = requestParameters(new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -2654,9 +2792,11 @@ public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(string index, Func<Cat
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				requestParams = requestParameters(new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -2681,21 +2821,23 @@ public Task<ElasticsearchResponse<T>> CatRecoveryAsync<T>(string index, Func<Cat
 		///<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> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				requestParams = requestParameters(new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
@@ -2715,21 +2857,23 @@ public ElasticsearchResponse<DynamicDictionary> CatRecovery(string index, Func<C
 		///<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>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/recovery/{0}".F(Encoded(index));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatRecoveryRequestParameters());
+				requestParams = requestParameters(new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatRecoveryRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/shards
@@ -2752,9 +2896,11 @@ public ElasticsearchResponse<T> CatShards<T>(Func<CatShardsRequestParameters, Ca
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatShardsRequestParameters());
+				requestParams = requestParameters(new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -2782,9 +2928,11 @@ public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(Func<CatShardsRequestPar
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatShardsRequestParameters());
+				requestParams = requestParameters(new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -2808,20 +2956,22 @@ public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(Func<CatShardsRequestPar
 		///<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> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/shards";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatShardsRequestParameters());
+				requestParams = requestParameters(new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/shards
@@ -2840,20 +2990,22 @@ public ElasticsearchResponse<DynamicDictionary> CatShards(Func<CatShardsRequestP
 		///<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>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/shards";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatShardsRequestParameters());
+				requestParams = requestParameters(new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
@@ -2878,9 +3030,11 @@ public ElasticsearchResponse<T> CatShards<T>(string index, Func<CatShardsRequest
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatShardsRequestParameters());
+				requestParams = requestParameters(new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -2910,9 +3064,11 @@ public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(string index, Func<CatSh
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatShardsRequestParameters());
+				requestParams = requestParameters(new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -2937,21 +3093,23 @@ public Task<ElasticsearchResponse<T>> CatShardsAsync<T>(string index, Func<CatSh
 		///<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> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatShardsRequestParameters());
+				requestParams = requestParameters(new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
@@ -2971,21 +3129,23 @@ public ElasticsearchResponse<DynamicDictionary> CatShards(string index, Func<Cat
 		///<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>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null)
 		{
 			index.ThrowIfNullOrEmpty("index");
 			var url = "_cat/shards/{0}".F(Encoded(index));
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatShardsRequestParameters());
+				requestParams = requestParameters(new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatShardsRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/thread_pool
@@ -3008,9 +3168,11 @@ public ElasticsearchResponse<T> CatThreadPool<T>(Func<CatThreadPoolRequestParame
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatThreadPoolRequestParameters());
+				requestParams = requestParameters(new CatThreadPoolRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatThreadPoolRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
@@ -3038,9 +3200,11 @@ public Task<ElasticsearchResponse<T>> CatThreadPoolAsync<T>(Func<CatThreadPoolRe
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatThreadPoolRequestParameters());
+				requestParams = requestParameters(new CatThreadPoolRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatThreadPoolRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
+
 
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
@@ -3064,20 +3228,22 @@ public Task<ElasticsearchResponse<T>> CatThreadPoolAsync<T>(Func<CatThreadPoolRe
 		///<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> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null)
+		public ElasticsearchResponse<string> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/thread_pool";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatThreadPoolRequestParameters());
+				requestParams = requestParameters(new CatThreadPoolRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatThreadPoolRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
+
+			return this.DoRequest<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a GET on /_cat/thread_pool
@@ -3096,20 +3262,22 @@ public ElasticsearchResponse<DynamicDictionary> CatThreadPool(Func<CatThreadPool
 		///<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>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null)
+		public Task<ElasticsearchResponse<string>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null)
 		{
 			var url = "_cat/thread_pool";
 			BaseRequestParameters requestParams = null;
 			if (requestParameters != null)
 			{
-				requestParams = requestParameters(new CatThreadPoolRequestParameters());
+				requestParams = requestParameters(new CatThreadPoolRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")));
 				ToNameValueCollection(requestParams);
 			}
+			else requestParams = new CatThreadPoolRequestParameters().RequestConfiguration(r=>r.ContentType("text/plain")); 
 
-			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
+
+			return this.DoRequestAsync<string>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
-			));
+			);
 		}
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
@@ -3138,6 +3306,7 @@ public ElasticsearchResponse<T> ClearScroll<T>(string scroll_id, Func<ClearScrol
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -3170,6 +3339,7 @@ public Task<ElasticsearchResponse<T>> ClearScrollAsync<T>(string scroll_id, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -3204,6 +3374,7 @@ public ElasticsearchResponse<DynamicDictionary> ClearScroll(string scroll_id, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -3238,6 +3409,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClearScrollAsync(string sc
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -3268,6 +3440,7 @@ public ElasticsearchResponse<T> ClusterGetSettings<T>(Func<ClusterGetSettingsReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3298,6 +3471,7 @@ public Task<ElasticsearchResponse<T>> ClusterGetSettingsAsync<T>(Func<ClusterGet
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3330,6 +3504,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterGetSettings(Func<ClusterG
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3362,6 +3537,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterGetSettingsAsync(Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3392,6 +3568,7 @@ public ElasticsearchResponse<T> ClusterHealth<T>(Func<ClusterHealthRequestParame
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3422,6 +3599,7 @@ public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(Func<ClusterHealthRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3454,6 +3632,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterHealth(Func<ClusterHealth
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3486,6 +3665,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(Func<Cl
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3518,6 +3698,7 @@ public ElasticsearchResponse<T> ClusterHealth<T>(string index, Func<ClusterHealt
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3550,6 +3731,7 @@ public Task<ElasticsearchResponse<T>> ClusterHealthAsync<T>(string index, Func<C
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3584,6 +3766,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterHealth(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3618,6 +3801,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterHealthAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3648,6 +3832,7 @@ public ElasticsearchResponse<T> ClusterPendingTasks<T>(Func<ClusterPendingTasksR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3678,6 +3863,7 @@ public Task<ElasticsearchResponse<T>> ClusterPendingTasksAsync<T>(Func<ClusterPe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3710,6 +3896,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterPendingTasks(Func<Cluster
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3742,6 +3929,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPendingTasksAsync(F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -3773,6 +3961,7 @@ public ElasticsearchResponse<T> ClusterPutSettings<T>(object body, Func<ClusterP
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -3804,6 +3993,7 @@ public Task<ElasticsearchResponse<T>> ClusterPutSettingsAsync<T>(object body, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -3837,6 +4027,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterPutSettings(object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -3870,6 +4061,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterPutSettingsAsync(ob
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -3901,6 +4093,7 @@ public ElasticsearchResponse<T> ClusterReroute<T>(object body, Func<ClusterRerou
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -3932,6 +4125,7 @@ public Task<ElasticsearchResponse<T>> ClusterRerouteAsync<T>(object body, Func<C
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -3965,6 +4159,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterReroute(object body, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -3998,6 +4193,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterRerouteAsync(object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4028,6 +4224,7 @@ public ElasticsearchResponse<T> ClusterState<T>(Func<ClusterStateRequestParamete
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4058,6 +4255,7 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(Func<ClusterStateRequ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4090,6 +4288,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(Func<ClusterStateRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4122,6 +4321,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(Func<Clu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4154,6 +4354,7 @@ public ElasticsearchResponse<T> ClusterState<T>(string metric, Func<ClusterState
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4186,6 +4387,7 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, Func<C
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4220,6 +4422,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4254,6 +4457,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string m
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4288,6 +4492,7 @@ public ElasticsearchResponse<T> ClusterState<T>(string metric, string index, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4322,6 +4527,7 @@ public Task<ElasticsearchResponse<T>> ClusterStateAsync<T>(string metric, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4358,6 +4564,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterState(string metric, stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4394,6 +4601,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStateAsync(string m
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4424,6 +4632,7 @@ public ElasticsearchResponse<T> ClusterStats<T>(Func<ClusterStatsRequestParamete
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4454,6 +4663,7 @@ public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(Func<ClusterStatsRequ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4486,6 +4696,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterStats(Func<ClusterStatsRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4518,6 +4729,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(Func<Clu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4550,6 +4762,7 @@ public ElasticsearchResponse<T> ClusterStats<T>(string node_id, Func<ClusterStat
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4582,6 +4795,7 @@ public Task<ElasticsearchResponse<T>> ClusterStatsAsync<T>(string node_id, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4616,6 +4830,7 @@ public ElasticsearchResponse<DynamicDictionary> ClusterStats(string node_id, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4650,6 +4865,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ClusterStatsAsync(string n
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -4681,6 +4897,7 @@ public ElasticsearchResponse<T> Count<T>(object body, Func<CountRequestParameter
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4712,6 +4929,7 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(object body, Func<CountReque
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4745,6 +4963,7 @@ public ElasticsearchResponse<DynamicDictionary> Count(object body, Func<CountReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4778,6 +4997,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(object body, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4811,6 +5031,7 @@ public ElasticsearchResponse<T> Count<T>(string index, object body, Func<CountRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4844,6 +5065,7 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, object body, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4879,6 +5101,7 @@ public ElasticsearchResponse<DynamicDictionary> Count(string index, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4914,6 +5137,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, o
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4949,6 +5173,7 @@ public ElasticsearchResponse<T> Count<T>(string index, string type, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -4984,6 +5209,7 @@ public Task<ElasticsearchResponse<T>> CountAsync<T>(string index, string type, o
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -5021,6 +5247,7 @@ public ElasticsearchResponse<DynamicDictionary> Count(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -5058,6 +5285,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountAsync(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -5088,6 +5316,7 @@ public ElasticsearchResponse<T> CountGet<T>(Func<CountRequestParameters, CountRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5118,6 +5347,7 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(Func<CountRequestParamete
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5150,6 +5380,7 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(Func<CountRequestParame
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5182,6 +5413,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(Func<CountRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5214,6 +5446,7 @@ public ElasticsearchResponse<T> CountGet<T>(string index, Func<CountRequestParam
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5246,6 +5479,7 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, Func<CountR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5280,6 +5514,7 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(string index, Func<Coun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5314,6 +5549,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5348,6 +5584,7 @@ public ElasticsearchResponse<T> CountGet<T>(string index, string type, Func<Coun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5382,6 +5619,7 @@ public Task<ElasticsearchResponse<T>> CountGetAsync<T>(string index, string type
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5418,6 +5656,7 @@ public ElasticsearchResponse<DynamicDictionary> CountGet(string index, string ty
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5454,6 +5693,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountGetAsync(string index
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5488,6 +5728,7 @@ public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5522,6 +5763,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5558,6 +5800,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5594,6 +5837,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5630,6 +5874,7 @@ public ElasticsearchResponse<T> CountPercolateGet<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5666,6 +5911,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateGetAsync<T>(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5704,6 +5950,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolateGet(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5742,6 +5989,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateGetAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -5777,6 +6025,7 @@ public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, obj
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -5812,6 +6061,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -5849,6 +6099,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -5886,6 +6137,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -5923,6 +6175,7 @@ public ElasticsearchResponse<T> CountPercolate<T>(string index, string type, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -5960,6 +6213,7 @@ public Task<ElasticsearchResponse<T>> CountPercolateAsync<T>(string index, strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -5999,6 +6253,7 @@ public ElasticsearchResponse<DynamicDictionary> CountPercolate(string index, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -6038,6 +6293,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> CountPercolateAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -6074,6 +6330,7 @@ public ElasticsearchResponse<T> Delete<T>(string index, string type, string id,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -6110,6 +6367,7 @@ public Task<ElasticsearchResponse<T>> DeleteAsync<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -6148,6 +6406,7 @@ public ElasticsearchResponse<DynamicDictionary> Delete(string index, string type
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -6186,6 +6445,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -6219,6 +6479,7 @@ public ElasticsearchResponse<T> DeleteByQuery<T>(string index, object body, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, body, 
 				requestParameters: requestParams
@@ -6252,6 +6513,7 @@ public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, body, 
 				requestParameters: requestParams
@@ -6287,6 +6549,7 @@ public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, obje
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, body, 
 				requestParameters: requestParams
@@ -6322,6 +6585,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, body, 
 				requestParameters: requestParams
@@ -6357,6 +6621,7 @@ public ElasticsearchResponse<T> DeleteByQuery<T>(string index, string type, obje
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, body, 
 				requestParameters: requestParams
@@ -6392,6 +6657,7 @@ public Task<ElasticsearchResponse<T>> DeleteByQueryAsync<T>(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, body, 
 				requestParameters: requestParams
@@ -6429,6 +6695,7 @@ public ElasticsearchResponse<DynamicDictionary> DeleteByQuery(string index, stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, body, 
 				requestParameters: requestParams
@@ -6466,6 +6733,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> DeleteByQueryAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, body, 
 				requestParameters: requestParams
@@ -6502,6 +6770,7 @@ public ElasticsearchResponse<T> Exists<T>(string index, string type, string id,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -6538,6 +6807,7 @@ public Task<ElasticsearchResponse<T>> ExistsAsync<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -6576,6 +6846,7 @@ public ElasticsearchResponse<DynamicDictionary> Exists(string index, string type
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -6614,6 +6885,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExistsAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -6650,6 +6922,7 @@ public ElasticsearchResponse<T> ExplainGet<T>(string index, string type, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -6686,6 +6959,7 @@ public Task<ElasticsearchResponse<T>> ExplainGetAsync<T>(string index, string ty
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -6724,6 +6998,7 @@ public ElasticsearchResponse<DynamicDictionary> ExplainGet(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -6762,6 +7037,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExplainGetAsync(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -6799,6 +7075,7 @@ public ElasticsearchResponse<T> Explain<T>(string index, string type, string id,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -6836,6 +7113,7 @@ public Task<ElasticsearchResponse<T>> ExplainAsync<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -6875,6 +7153,7 @@ public ElasticsearchResponse<DynamicDictionary> Explain(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -6914,6 +7193,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ExplainAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -6950,6 +7230,7 @@ public ElasticsearchResponse<T> Get<T>(string index, string type, string id, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -6986,6 +7267,7 @@ public Task<ElasticsearchResponse<T>> GetAsync<T>(string index, string type, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7024,6 +7306,7 @@ public ElasticsearchResponse<DynamicDictionary> Get(string index, string type, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7062,6 +7345,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetAsync(string index, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7098,6 +7382,7 @@ public ElasticsearchResponse<T> GetSource<T>(string index, string type, string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7134,6 +7419,7 @@ public Task<ElasticsearchResponse<T>> GetSourceAsync<T>(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7172,6 +7458,7 @@ public ElasticsearchResponse<DynamicDictionary> GetSource(string index, string t
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7210,6 +7497,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> GetSourceAsync(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7245,6 +7533,7 @@ public ElasticsearchResponse<T> Index<T>(string index, string type, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -7280,6 +7569,7 @@ public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, o
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -7317,6 +7607,7 @@ public ElasticsearchResponse<DynamicDictionary> Index(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -7354,6 +7645,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -7391,6 +7683,7 @@ public ElasticsearchResponse<T> Index<T>(string index, string type, string id, o
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -7428,6 +7721,7 @@ public Task<ElasticsearchResponse<T>> IndexAsync<T>(string index, string type, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -7467,6 +7761,7 @@ public ElasticsearchResponse<DynamicDictionary> Index(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -7506,6 +7801,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexAsync(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -7541,6 +7837,7 @@ public ElasticsearchResponse<T> IndexPut<T>(string index, string type, object bo
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -7576,6 +7873,7 @@ public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -7613,6 +7911,7 @@ public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string ty
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -7650,6 +7949,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -7687,6 +7987,7 @@ public ElasticsearchResponse<T> IndexPut<T>(string index, string type, string id
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -7724,6 +8025,7 @@ public Task<ElasticsearchResponse<T>> IndexPutAsync<T>(string index, string type
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -7763,6 +8065,7 @@ public ElasticsearchResponse<DynamicDictionary> IndexPut(string index, string ty
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -7802,6 +8105,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndexPutAsync(string index
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -7832,6 +8136,7 @@ public ElasticsearchResponse<T> IndicesAnalyzeGetForAll<T>(Func<AnalyzeRequestPa
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7862,6 +8167,7 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetForAllAsync<T>(Func<Analy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7894,6 +8200,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGetForAll(Func<Ana
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7926,6 +8233,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetForAllAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7958,6 +8266,7 @@ public ElasticsearchResponse<T> IndicesAnalyzeGet<T>(string index, Func<AnalyzeR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -7990,6 +8299,7 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeGetAsync<T>(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8024,6 +8334,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeGet(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8058,6 +8369,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeGetAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8089,6 +8401,7 @@ public ElasticsearchResponse<T> IndicesAnalyzeForAll<T>(object body, Func<Analyz
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -8120,6 +8433,7 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeForAllAsync<T>(object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -8153,6 +8467,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyzeForAll(object body
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -8186,6 +8501,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeForAllAsync(
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -8219,6 +8535,7 @@ public ElasticsearchResponse<T> IndicesAnalyze<T>(string index, object body, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -8252,6 +8569,7 @@ public Task<ElasticsearchResponse<T>> IndicesAnalyzeAsync<T>(string index, objec
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -8287,6 +8605,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesAnalyze(string index, obj
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -8322,6 +8641,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesAnalyzeAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -8352,6 +8672,7 @@ public ElasticsearchResponse<T> IndicesClearCacheForAll<T>(Func<ClearCacheReques
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8382,6 +8703,7 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheForAllAsync<T>(Func<Clear
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8414,6 +8736,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheForAll(Func<Cle
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8446,6 +8769,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheForAllAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8478,6 +8802,7 @@ public ElasticsearchResponse<T> IndicesClearCache<T>(string index, Func<ClearCac
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8510,6 +8835,7 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheAsync<T>(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8544,6 +8870,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCache(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8578,6 +8905,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8608,6 +8936,7 @@ public ElasticsearchResponse<T> IndicesClearCacheGetForAll<T>(Func<ClearCacheReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8638,6 +8967,7 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheGetForAllAsync<T>(Func<Cl
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8670,6 +9000,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGetForAll(Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8702,6 +9033,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetForAll
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8734,6 +9066,7 @@ public ElasticsearchResponse<T> IndicesClearCacheGet<T>(string index, Func<Clear
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8766,6 +9099,7 @@ public Task<ElasticsearchResponse<T>> IndicesClearCacheGetAsync<T>(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8800,6 +9134,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClearCacheGet(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8834,6 +9169,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesClearCacheGetAsync(
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -8866,6 +9202,7 @@ public ElasticsearchResponse<T> IndicesClose<T>(string index, Func<CloseIndexReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8898,6 +9235,7 @@ public Task<ElasticsearchResponse<T>> IndicesCloseAsync<T>(string index, Func<Cl
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8932,6 +9270,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesClose(string index, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8966,6 +9305,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCloseAsync(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -8999,6 +9339,7 @@ public ElasticsearchResponse<T> IndicesCreate<T>(string index, object body, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -9032,6 +9373,7 @@ public Task<ElasticsearchResponse<T>> IndicesCreateAsync<T>(string index, object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -9067,6 +9409,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesCreate(string index, obje
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -9102,6 +9445,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreateAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -9135,6 +9479,7 @@ public ElasticsearchResponse<T> IndicesCreatePost<T>(string index, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -9168,6 +9513,7 @@ public Task<ElasticsearchResponse<T>> IndicesCreatePostAsync<T>(string index, ob
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -9203,6 +9549,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesCreatePost(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -9238,6 +9585,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesCreatePostAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -9270,6 +9618,7 @@ public ElasticsearchResponse<T> IndicesDelete<T>(string index, Func<DeleteIndexR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9302,6 +9651,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteAsync<T>(string index, Func<D
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9336,6 +9686,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDelete(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9370,6 +9721,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9404,6 +9756,7 @@ public ElasticsearchResponse<T> IndicesDeleteAlias<T>(string index, string name,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9438,6 +9791,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteAliasAsync<T>(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9474,6 +9828,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteAlias(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9510,6 +9865,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteAliasAsync(st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9544,6 +9900,7 @@ public ElasticsearchResponse<T> IndicesDeleteMapping<T>(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9578,6 +9935,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteMappingAsync<T>(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9614,6 +9972,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteMapping(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9650,6 +10009,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteMappingAsync(
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9682,6 +10042,7 @@ public ElasticsearchResponse<T> IndicesDeleteTemplateForAll<T>(string name, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9714,6 +10075,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteTemplateForAllAsync<T>(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9748,6 +10110,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteTemplateForAll(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9782,6 +10145,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteTemplateForAl
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9816,6 +10180,7 @@ public ElasticsearchResponse<T> IndicesDeleteWarmer<T>(string index, string name
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9850,6 +10215,7 @@ public Task<ElasticsearchResponse<T>> IndicesDeleteWarmerAsync<T>(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9886,6 +10252,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesDeleteWarmer(string index
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9922,6 +10289,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesDeleteWarmerAsync(s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -9954,6 +10322,7 @@ public ElasticsearchResponse<T> IndicesExists<T>(string index, Func<IndexExistsR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -9986,6 +10355,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAsync<T>(string index, Func<I
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10020,6 +10390,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExists(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10054,6 +10425,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10086,6 +10458,7 @@ public ElasticsearchResponse<T> IndicesExistsAliasForAll<T>(string name, Func<In
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10118,6 +10491,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasForAllAsync<T>(string na
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10152,6 +10526,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAliasForAll(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10186,6 +10561,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasForAllAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10220,6 +10596,7 @@ public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, string name,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10254,6 +10631,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10290,6 +10668,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10326,6 +10705,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10358,6 +10738,7 @@ public ElasticsearchResponse<T> IndicesExistsAlias<T>(string index, Func<Indices
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10390,6 +10771,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsAliasAsync<T>(string index, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10424,6 +10806,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsAlias(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10458,6 +10841,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsAliasAsync(st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10490,6 +10874,7 @@ public ElasticsearchResponse<T> IndicesExistsTemplateForAll<T>(string name, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10522,6 +10907,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsTemplateForAllAsync<T>(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10556,6 +10942,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsTemplateForAll(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10590,6 +10977,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTemplateForAl
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10624,6 +11012,7 @@ public ElasticsearchResponse<T> IndicesExistsType<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10658,6 +11047,7 @@ public Task<ElasticsearchResponse<T>> IndicesExistsTypeAsync<T>(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10694,6 +11084,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesExistsType(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10730,6 +11121,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesExistsTypeAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -10760,6 +11152,7 @@ public ElasticsearchResponse<T> IndicesFlushForAll<T>(Func<FlushRequestParameter
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -10790,6 +11183,7 @@ public Task<ElasticsearchResponse<T>> IndicesFlushForAllAsync<T>(Func<FlushReque
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -10822,6 +11216,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlushForAll(Func<FlushReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -10854,6 +11249,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushForAllAsync(Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -10886,6 +11282,7 @@ public ElasticsearchResponse<T> IndicesFlush<T>(string index, Func<FlushRequestP
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -10918,6 +11315,7 @@ public Task<ElasticsearchResponse<T>> IndicesFlushAsync<T>(string index, Func<Fl
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -10952,6 +11350,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlush(string index, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -10986,6 +11385,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushAsync(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -11016,6 +11416,7 @@ public ElasticsearchResponse<T> IndicesFlushGetForAll<T>(Func<FlushRequestParame
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11046,6 +11447,7 @@ public Task<ElasticsearchResponse<T>> IndicesFlushGetForAllAsync<T>(Func<FlushRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11078,6 +11480,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlushGetForAll(Func<Flush
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11110,6 +11513,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetForAllAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11142,6 +11546,7 @@ public ElasticsearchResponse<T> IndicesFlushGet<T>(string index, Func<FlushReque
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11174,6 +11579,7 @@ public Task<ElasticsearchResponse<T>> IndicesFlushGetAsync<T>(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11208,6 +11614,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesFlushGet(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11242,6 +11649,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesFlushGetAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11272,6 +11680,7 @@ public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(Func<GetAliasesRequestP
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11302,6 +11711,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(Func<GetAlia
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11334,6 +11744,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(Func<GetAl
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11366,6 +11777,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11398,6 +11810,7 @@ public ElasticsearchResponse<T> IndicesGetAliasForAll<T>(string name, Func<GetAl
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11430,6 +11843,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasForAllAsync<T>(string name,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11464,6 +11878,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasForAll(string nam
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11498,6 +11913,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasForAllAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11532,6 +11948,7 @@ public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, string name, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11566,6 +11983,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11602,6 +12020,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11638,6 +12057,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11670,6 +12090,7 @@ public ElasticsearchResponse<T> IndicesGetAlias<T>(string index, Func<GetAliases
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11702,6 +12123,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasAsync<T>(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11736,6 +12158,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAlias(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11770,6 +12193,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11800,6 +12224,7 @@ public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(Func<IndicesGetAliase
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11830,6 +12255,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(Func<Indic
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11862,6 +12288,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(Func<Ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11894,6 +12321,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11926,6 +12354,7 @@ public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, Func<IndicesG
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11958,6 +12387,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -11992,6 +12422,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12026,6 +12457,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12060,6 +12492,7 @@ public ElasticsearchResponse<T> IndicesGetAliases<T>(string index, string name,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12094,6 +12527,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesAsync<T>(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12130,6 +12564,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliases(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12166,6 +12601,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12198,6 +12634,7 @@ public ElasticsearchResponse<T> IndicesGetAliasesForAll<T>(string name, Func<Ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12230,6 +12667,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetAliasesForAllAsync<T>(string nam
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12264,6 +12702,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetAliasesForAll(string n
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12298,6 +12737,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetAliasesForAllAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12330,6 +12770,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string field, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12362,6 +12803,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12396,6 +12838,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12430,6 +12873,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForA
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12464,6 +12908,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string f
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12498,6 +12943,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12534,6 +12980,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string in
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12570,6 +13017,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsyn
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12604,6 +13052,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMappingForAll<T>(string type, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12638,6 +13087,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingForAllAsync<T>(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12674,6 +13124,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMappingForAll(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12710,6 +13161,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingForA
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12746,6 +13198,7 @@ public ElasticsearchResponse<T> IndicesGetFieldMapping<T>(string index, string t
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12782,6 +13235,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetFieldMappingAsync<T>(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12820,6 +13274,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetFieldMapping(string in
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12858,6 +13313,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetFieldMappingAsyn
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12888,6 +13344,7 @@ public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(Func<GetMappingReques
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12918,6 +13375,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(Func<GetMa
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12950,6 +13408,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(Func<Get
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -12982,6 +13441,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13014,6 +13474,7 @@ public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, Func<GetMappi
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13046,6 +13507,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13080,6 +13542,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13114,6 +13577,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13146,6 +13610,7 @@ public ElasticsearchResponse<T> IndicesGetMappingForAll<T>(string type, Func<Get
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13178,6 +13643,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingForAllAsync<T>(string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13212,6 +13678,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMappingForAll(string t
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13246,6 +13713,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingForAllAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13280,6 +13748,7 @@ public ElasticsearchResponse<T> IndicesGetMapping<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13314,6 +13783,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetMappingAsync<T>(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13350,6 +13820,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetMapping(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13386,6 +13857,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetMappingAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13416,6 +13888,7 @@ public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(Func<GetIndexSetting
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13446,6 +13919,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(Func<GetI
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13478,6 +13952,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(Func<Ge
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13510,6 +13985,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13542,6 +14018,7 @@ public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, Func<GetInde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13574,6 +14051,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13608,6 +14086,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13642,6 +14121,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13676,6 +14156,7 @@ public ElasticsearchResponse<T> IndicesGetSettings<T>(string index, string name,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13710,6 +14191,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsAsync<T>(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13746,6 +14228,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettings(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13782,6 +14265,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsAsync(st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13814,6 +14298,7 @@ public ElasticsearchResponse<T> IndicesGetSettingsForAll<T>(string name, Func<Ge
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13846,6 +14331,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetSettingsForAllAsync<T>(string na
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13880,6 +14366,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetSettingsForAll(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13914,6 +14401,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetSettingsForAllAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13944,6 +14432,7 @@ public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(Func<GetTemplateRequ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -13974,6 +14463,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(Func<GetT
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14006,6 +14496,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(Func<Ge
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14038,6 +14529,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14070,6 +14562,7 @@ public ElasticsearchResponse<T> IndicesGetTemplateForAll<T>(string name, Func<Ge
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14102,6 +14595,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetTemplateForAllAsync<T>(string na
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14136,6 +14630,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetTemplateForAll(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14170,6 +14665,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetTemplateForAllAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14200,6 +14696,7 @@ public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(Func<GetWarmerRequestP
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14230,6 +14727,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(Func<GetWar
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14262,6 +14760,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(Func<GetW
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14294,6 +14793,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsyn
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14326,6 +14826,7 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, Func<GetWarmer
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14358,6 +14859,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14392,6 +14894,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14426,6 +14929,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14460,6 +14964,7 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string name, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14494,6 +14999,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14530,6 +15036,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14566,6 +15073,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14598,6 +15106,7 @@ public ElasticsearchResponse<T> IndicesGetWarmerForAll<T>(string name, Func<GetW
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14630,6 +15139,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerForAllAsync<T>(string name
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14664,6 +15174,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmerForAll(string na
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14698,6 +15209,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerForAllAsyn
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14734,6 +15246,7 @@ public ElasticsearchResponse<T> IndicesGetWarmer<T>(string index, string type, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14770,6 +15283,7 @@ public Task<ElasticsearchResponse<T>> IndicesGetWarmerAsync<T>(string index, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14808,6 +15322,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesGetWarmer(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14846,6 +15361,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesGetWarmerAsync(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -14878,6 +15394,7 @@ public ElasticsearchResponse<T> IndicesOpen<T>(string index, Func<OpenIndexReque
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -14910,6 +15427,7 @@ public Task<ElasticsearchResponse<T>> IndicesOpenAsync<T>(string index, Func<Ope
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -14944,6 +15462,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOpen(string index, Func<O
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -14978,6 +15497,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOpenAsync(string in
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -15008,6 +15528,7 @@ public ElasticsearchResponse<T> IndicesOptimizeForAll<T>(Func<OptimizeRequestPar
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -15038,6 +15559,7 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeForAllAsync<T>(Func<Optimiz
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -15070,6 +15592,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeForAll(Func<Optim
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -15102,6 +15625,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeForAllAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -15134,6 +15658,7 @@ public ElasticsearchResponse<T> IndicesOptimize<T>(string index, Func<OptimizeRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -15166,6 +15691,7 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeAsync<T>(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -15200,6 +15726,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimize(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -15234,6 +15761,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -15264,6 +15792,7 @@ public ElasticsearchResponse<T> IndicesOptimizeGetForAll<T>(Func<OptimizeRequest
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -15294,6 +15823,7 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeGetForAllAsync<T>(Func<Opti
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -15326,6 +15856,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGetForAll(Func<Op
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -15358,6 +15889,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetForAllAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -15390,6 +15922,7 @@ public ElasticsearchResponse<T> IndicesOptimizeGet<T>(string index, Func<Optimiz
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -15422,6 +15955,7 @@ public Task<ElasticsearchResponse<T>> IndicesOptimizeGetAsync<T>(string index, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -15456,6 +15990,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesOptimizeGet(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -15490,6 +16025,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesOptimizeGetAsync(st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -15525,6 +16061,7 @@ public ElasticsearchResponse<T> IndicesPutAlias<T>(string index, string name, ob
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -15560,6 +16097,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasAsync<T>(string index, stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -15597,6 +16135,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAlias(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -15634,6 +16173,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -15667,6 +16207,7 @@ public ElasticsearchResponse<T> IndicesPutAliasForAll<T>(string name, object bod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -15700,6 +16241,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasForAllAsync<T>(string name,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -15735,6 +16277,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasForAll(string nam
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -15770,6 +16313,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasForAllAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -15805,6 +16349,7 @@ public ElasticsearchResponse<T> IndicesPutAliasPost<T>(string index, string name
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -15840,6 +16385,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasPostAsync<T>(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -15877,6 +16423,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPost(string index
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -15914,6 +16461,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostAsync(s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -15947,6 +16495,7 @@ public ElasticsearchResponse<T> IndicesPutAliasPostForAll<T>(string name, object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -15980,6 +16529,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutAliasPostForAllAsync<T>(string n
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16015,6 +16565,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutAliasPostForAll(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16050,6 +16601,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutAliasPostForAllA
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16085,6 +16637,7 @@ public ElasticsearchResponse<T> IndicesPutMapping<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16120,6 +16673,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingAsync<T>(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16157,6 +16711,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMapping(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16194,6 +16749,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16227,6 +16783,7 @@ public ElasticsearchResponse<T> IndicesPutMappingForAll<T>(string type, object b
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16260,6 +16817,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingForAllAsync<T>(string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16295,6 +16853,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingForAll(string t
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16330,6 +16889,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingForAllAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16365,6 +16925,7 @@ public ElasticsearchResponse<T> IndicesPutMappingPost<T>(string index, string ty
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16400,6 +16961,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingPostAsync<T>(string index
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16437,6 +16999,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPost(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16474,6 +17037,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16507,6 +17071,7 @@ public ElasticsearchResponse<T> IndicesPutMappingPostForAll<T>(string type, obje
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16540,6 +17105,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutMappingPostForAllAsync<T>(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16575,6 +17141,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutMappingPostForAll(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16610,6 +17177,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutMappingPostForAl
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -16641,6 +17209,7 @@ public ElasticsearchResponse<T> IndicesPutSettingsForAll<T>(object body, Func<Up
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16672,6 +17241,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutSettingsForAllAsync<T>(object bo
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16705,6 +17275,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutSettingsForAll(object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16738,6 +17309,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsForAllAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16771,6 +17343,7 @@ public ElasticsearchResponse<T> IndicesPutSettings<T>(string index, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16804,6 +17377,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutSettingsAsync<T>(string index, o
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16839,6 +17413,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutSettings(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16874,6 +17449,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutSettingsAsync(st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16907,6 +17483,7 @@ public ElasticsearchResponse<T> IndicesPutTemplateForAll<T>(string name, object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16940,6 +17517,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutTemplateForAllAsync<T>(string na
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -16975,6 +17553,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplateForAll(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17010,6 +17589,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplateForAllAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17043,6 +17623,7 @@ public ElasticsearchResponse<T> IndicesPutTemplatePostForAll<T>(string name, obj
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17076,6 +17657,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutTemplatePostForAllAsync<T>(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17111,6 +17693,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutTemplatePostForAll(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17146,6 +17729,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutTemplatePostForA
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17179,6 +17763,7 @@ public ElasticsearchResponse<T> IndicesPutWarmerForAll<T>(string name, object bo
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17212,6 +17797,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerForAllAsync<T>(string name
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17247,6 +17833,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerForAll(string na
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17282,6 +17869,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerForAllAsyn
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17317,6 +17905,7 @@ public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string name, o
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17352,6 +17941,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17389,6 +17979,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17426,6 +18017,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17463,6 +18055,7 @@ public ElasticsearchResponse<T> IndicesPutWarmer<T>(string index, string type, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17500,6 +18093,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerAsync<T>(string index, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17539,6 +18133,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmer(string index, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17578,6 +18173,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerAsync(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -17611,6 +18207,7 @@ public ElasticsearchResponse<T> IndicesPutWarmerPostForAll<T>(string name, objec
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17644,6 +18241,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostForAllAsync<T>(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17679,6 +18277,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPostForAll(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17714,6 +18313,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostForAll
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17749,6 +18349,7 @@ public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string nam
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17784,6 +18385,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17821,6 +18423,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17858,6 +18461,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17895,6 +18499,7 @@ public ElasticsearchResponse<T> IndicesPutWarmerPost<T>(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17932,6 +18537,7 @@ public Task<ElasticsearchResponse<T>> IndicesPutWarmerPostAsync<T>(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -17971,6 +18577,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesPutWarmerPost(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -18010,6 +18617,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesPutWarmerPostAsync(
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -18040,6 +18648,7 @@ public ElasticsearchResponse<T> IndicesRefreshForAll<T>(Func<RefreshRequestParam
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18070,6 +18679,7 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshForAllAsync<T>(Func<RefreshR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18102,6 +18712,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefreshForAll(Func<Refres
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18134,6 +18745,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshForAllAsync(
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18166,6 +18778,7 @@ public ElasticsearchResponse<T> IndicesRefresh<T>(string index, Func<RefreshRequ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18198,6 +18811,7 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshAsync<T>(string index, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18232,6 +18846,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefresh(string index, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18266,6 +18881,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18296,6 +18912,7 @@ public ElasticsearchResponse<T> IndicesRefreshGetForAll<T>(Func<RefreshRequestPa
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18326,6 +18943,7 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshGetForAllAsync<T>(Func<Refre
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18358,6 +18976,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGetForAll(Func<Ref
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18390,6 +19009,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetForAllAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18422,6 +19042,7 @@ public ElasticsearchResponse<T> IndicesRefreshGet<T>(string index, Func<RefreshR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18454,6 +19075,7 @@ public Task<ElasticsearchResponse<T>> IndicesRefreshGetAsync<T>(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18488,6 +19110,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesRefreshGet(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18522,6 +19145,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesRefreshGetAsync(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18552,6 +19176,7 @@ public ElasticsearchResponse<T> IndicesSegmentsForAll<T>(Func<SegmentsRequestPar
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18582,6 +19207,7 @@ public Task<ElasticsearchResponse<T>> IndicesSegmentsForAllAsync<T>(Func<Segment
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18614,6 +19240,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSegmentsForAll(Func<Segme
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18646,6 +19273,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsForAllAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18678,6 +19306,7 @@ public ElasticsearchResponse<T> IndicesSegments<T>(string index, Func<SegmentsRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18710,6 +19339,7 @@ public Task<ElasticsearchResponse<T>> IndicesSegmentsAsync<T>(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18744,6 +19374,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSegments(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18778,6 +19409,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSegmentsAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -18808,6 +19440,7 @@ public ElasticsearchResponse<T> IndicesSnapshotIndexForAll<T>(Func<SnapshotReque
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18838,6 +19471,7 @@ public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexForAllAsync<T>(Func<Sn
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18870,6 +19504,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndexForAll(Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18902,6 +19537,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexForAll
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18934,6 +19570,7 @@ public ElasticsearchResponse<T> IndicesSnapshotIndex<T>(string index, Func<Snaps
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -18966,6 +19603,7 @@ public Task<ElasticsearchResponse<T>> IndicesSnapshotIndexAsync<T>(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -19000,6 +19638,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesSnapshotIndex(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -19034,6 +19673,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesSnapshotIndexAsync(
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -19064,6 +19704,7 @@ public ElasticsearchResponse<T> IndicesStatsForAll<T>(Func<IndicesStatsRequestPa
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19094,6 +19735,7 @@ public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(Func<IndicesSta
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19126,6 +19768,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(Func<IndicesS
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19158,6 +19801,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19190,6 +19834,7 @@ public ElasticsearchResponse<T> IndicesStatsForAll<T>(string metric, Func<Indice
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19222,6 +19867,7 @@ public Task<ElasticsearchResponse<T>> IndicesStatsForAllAsync<T>(string metric,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19256,6 +19902,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatsForAll(string metric
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19290,6 +19937,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsForAllAsync(st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19322,6 +19970,7 @@ public ElasticsearchResponse<T> IndicesStats<T>(string index, Func<IndicesStatsR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19354,6 +20003,7 @@ public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, Func<In
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19388,6 +20038,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19422,6 +20073,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19456,6 +20108,7 @@ public ElasticsearchResponse<T> IndicesStats<T>(string index, string metric, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19490,6 +20143,7 @@ public Task<ElasticsearchResponse<T>> IndicesStatsAsync<T>(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19526,6 +20180,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStats(string index, strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19562,6 +20217,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatsAsync(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19592,6 +20248,7 @@ public ElasticsearchResponse<T> IndicesStatusForAll<T>(Func<IndicesStatusRequest
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19622,6 +20279,7 @@ public Task<ElasticsearchResponse<T>> IndicesStatusForAllAsync<T>(Func<IndicesSt
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19654,6 +20312,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatusForAll(Func<Indices
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19686,6 +20345,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusForAllAsync(F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19718,6 +20378,7 @@ public ElasticsearchResponse<T> IndicesStatus<T>(string index, Func<IndicesStatu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19750,6 +20411,7 @@ public Task<ElasticsearchResponse<T>> IndicesStatusAsync<T>(string index, Func<I
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19784,6 +20446,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesStatus(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19818,6 +20481,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesStatusAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -19849,6 +20513,7 @@ public ElasticsearchResponse<T> IndicesUpdateAliasesForAll<T>(object body, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -19880,6 +20545,7 @@ public Task<ElasticsearchResponse<T>> IndicesUpdateAliasesForAllAsync<T>(object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -19913,6 +20579,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesUpdateAliasesForAll(objec
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -19946,6 +20613,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesUpdateAliasesForAll
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -19976,6 +20644,7 @@ public ElasticsearchResponse<T> IndicesValidateQueryGetForAll<T>(Func<ValidateQu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20006,6 +20675,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetForAllAsync<T>(Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20038,6 +20708,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGetForAll(Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20070,6 +20741,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetFor
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20102,6 +20774,7 @@ public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, Func<Va
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20134,6 +20807,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20168,6 +20842,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20202,6 +20877,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20236,6 +20912,7 @@ public ElasticsearchResponse<T> IndicesValidateQueryGet<T>(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20270,6 +20947,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryGetAsync<T>(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20306,6 +20984,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryGet(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20342,6 +21021,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryGetAsy
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20373,6 +21053,7 @@ public ElasticsearchResponse<T> IndicesValidateQueryForAll<T>(object body, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20404,6 +21085,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryForAllAsync<T>(object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20437,6 +21119,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQueryForAll(objec
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20470,6 +21153,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryForAll
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20503,6 +21187,7 @@ public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, object bod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20536,6 +21221,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20571,6 +21257,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20606,6 +21293,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20641,6 +21329,7 @@ public ElasticsearchResponse<T> IndicesValidateQuery<T>(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20676,6 +21365,7 @@ public Task<ElasticsearchResponse<T>> IndicesValidateQueryAsync<T>(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20713,6 +21403,7 @@ public ElasticsearchResponse<DynamicDictionary> IndicesValidateQuery(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20750,6 +21441,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> IndicesValidateQueryAsync(
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -20780,6 +21472,7 @@ public ElasticsearchResponse<T> Info<T>(Func<InfoRequestParameters, InfoRequestP
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20810,6 +21503,7 @@ public Task<ElasticsearchResponse<T>> InfoAsync<T>(Func<InfoRequestParameters, I
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20842,6 +21536,7 @@ public ElasticsearchResponse<DynamicDictionary> Info(Func<InfoRequestParameters,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20874,6 +21569,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> InfoAsync(Func<InfoRequest
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20904,6 +21600,7 @@ public ElasticsearchResponse<T> MgetGet<T>(Func<MultiGetRequestParameters, Multi
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20934,6 +21631,7 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(Func<MultiGetRequestParame
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20966,6 +21664,7 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(Func<MultiGetRequestPara
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -20998,6 +21697,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(Func<MultiGet
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21030,6 +21730,7 @@ public ElasticsearchResponse<T> MgetGet<T>(string index, Func<MultiGetRequestPar
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21062,6 +21763,7 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, Func<MultiGe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21096,6 +21798,7 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, Func<Multi
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21130,6 +21833,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21164,6 +21868,7 @@ public ElasticsearchResponse<T> MgetGet<T>(string index, string type, Func<Multi
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21198,6 +21903,7 @@ public Task<ElasticsearchResponse<T>> MgetGetAsync<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21234,6 +21940,7 @@ public ElasticsearchResponse<DynamicDictionary> MgetGet(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21270,6 +21977,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetGetAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21301,6 +22009,7 @@ public ElasticsearchResponse<T> Mget<T>(object body, Func<MultiGetRequestParamet
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21332,6 +22041,7 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(object body, Func<MultiGetReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21365,6 +22075,7 @@ public ElasticsearchResponse<DynamicDictionary> Mget(object body, Func<MultiGetR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21398,6 +22109,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(object body, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21431,6 +22143,7 @@ public ElasticsearchResponse<T> Mget<T>(string index, object body, Func<MultiGet
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21464,6 +22177,7 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, object body, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21499,6 +22213,7 @@ public ElasticsearchResponse<DynamicDictionary> Mget(string index, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21534,6 +22249,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, ob
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21569,6 +22285,7 @@ public ElasticsearchResponse<T> Mget<T>(string index, string type, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21604,6 +22321,7 @@ public Task<ElasticsearchResponse<T>> MgetAsync<T>(string index, string type, ob
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21641,6 +22359,7 @@ public ElasticsearchResponse<DynamicDictionary> Mget(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21678,6 +22397,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MgetAsync(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21714,6 +22434,7 @@ public ElasticsearchResponse<T> MltGet<T>(string index, string type, string id,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21750,6 +22471,7 @@ public Task<ElasticsearchResponse<T>> MltGetAsync<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21788,6 +22510,7 @@ public ElasticsearchResponse<DynamicDictionary> MltGet(string index, string type
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21826,6 +22549,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MltGetAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -21863,6 +22587,7 @@ public ElasticsearchResponse<T> Mlt<T>(string index, string type, string id, obj
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21900,6 +22625,7 @@ public Task<ElasticsearchResponse<T>> MltAsync<T>(string index, string type, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21939,6 +22665,7 @@ public ElasticsearchResponse<DynamicDictionary> Mlt(string index, string type, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -21978,6 +22705,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MltAsync(string index, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22008,6 +22736,7 @@ public ElasticsearchResponse<T> MpercolateGet<T>(Func<MpercolateRequestParameter
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22038,6 +22767,7 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(Func<MpercolateReque
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22070,6 +22800,7 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(Func<MpercolateReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22102,6 +22833,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(Func<Mp
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22134,6 +22866,7 @@ public ElasticsearchResponse<T> MpercolateGet<T>(string index, Func<MpercolateRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22166,6 +22899,7 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, Func<M
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22200,6 +22934,7 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22234,6 +22969,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22268,6 +23004,7 @@ public ElasticsearchResponse<T> MpercolateGet<T>(string index, string type, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22302,6 +23039,7 @@ public Task<ElasticsearchResponse<T>> MpercolateGetAsync<T>(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22338,6 +23076,7 @@ public ElasticsearchResponse<DynamicDictionary> MpercolateGet(string index, stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22374,6 +23113,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateGetAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22405,6 +23145,7 @@ public ElasticsearchResponse<T> Mpercolate<T>(object body, Func<MpercolateReques
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22436,6 +23177,7 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(object body, Func<Mperc
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22469,6 +23211,7 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(object body, Func<Mpe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22502,6 +23245,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(object bod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22535,6 +23279,7 @@ public ElasticsearchResponse<T> Mpercolate<T>(string index, object body, Func<Mp
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22568,6 +23313,7 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, object bo
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22603,6 +23349,7 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22638,6 +23385,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22673,6 +23421,7 @@ public ElasticsearchResponse<T> Mpercolate<T>(string index, string type, object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22708,6 +23457,7 @@ public Task<ElasticsearchResponse<T>> MpercolateAsync<T>(string index, string ty
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22745,6 +23495,7 @@ public ElasticsearchResponse<DynamicDictionary> Mpercolate(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22782,6 +23533,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MpercolateAsync(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -22812,6 +23564,7 @@ public ElasticsearchResponse<T> MsearchGet<T>(Func<MultiSearchRequestParameters,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22842,6 +23595,7 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(Func<MultiSearchRequest
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22874,6 +23628,7 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(Func<MultiSearchReque
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22906,6 +23661,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(Func<Multi
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22938,6 +23694,7 @@ public ElasticsearchResponse<T> MsearchGet<T>(string index, Func<MultiSearchRequ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -22970,6 +23727,7 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, Func<Mult
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23004,6 +23762,7 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, Func<Mu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23038,6 +23797,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23072,6 +23832,7 @@ public ElasticsearchResponse<T> MsearchGet<T>(string index, string type, Func<Mu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23106,6 +23867,7 @@ public Task<ElasticsearchResponse<T>> MsearchGetAsync<T>(string index, string ty
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23142,6 +23904,7 @@ public ElasticsearchResponse<DynamicDictionary> MsearchGet(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23178,6 +23941,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchGetAsync(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23209,6 +23973,7 @@ public ElasticsearchResponse<T> Msearch<T>(object body, Func<MultiSearchRequestP
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23240,6 +24005,7 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(object body, Func<MultiSea
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23273,6 +24039,7 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(object body, Func<MultiS
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23306,6 +24073,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23339,6 +24107,7 @@ public ElasticsearchResponse<T> Msearch<T>(string index, object body, Func<Multi
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23372,6 +24141,7 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23407,6 +24177,7 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(string index, object bod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23442,6 +24213,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23477,6 +24249,7 @@ public ElasticsearchResponse<T> Msearch<T>(string index, string type, object bod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23512,6 +24285,7 @@ public Task<ElasticsearchResponse<T>> MsearchAsync<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23549,6 +24323,7 @@ public ElasticsearchResponse<DynamicDictionary> Msearch(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23586,6 +24361,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MsearchAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -23616,6 +24392,7 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(Func<MtermvectorsRequestParam
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23646,6 +24423,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(Func<MtermvectorsR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23678,6 +24456,7 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(Func<Mtermvector
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23710,6 +24489,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23742,6 +24522,7 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, Func<Mtermvecto
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23774,6 +24555,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23808,6 +24590,7 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23842,6 +24625,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23876,6 +24660,7 @@ public ElasticsearchResponse<T> MtermvectorsGet<T>(string index, string type, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23910,6 +24695,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsGetAsync<T>(string index, stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23946,6 +24732,7 @@ public ElasticsearchResponse<DynamicDictionary> MtermvectorsGet(string index, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -23982,6 +24769,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsGetAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24013,6 +24801,7 @@ public ElasticsearchResponse<T> Mtermvectors<T>(object body, Func<MtermvectorsRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24044,6 +24833,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(object body, Func<Mte
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24077,6 +24867,7 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(object body, Func<M
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24110,6 +24901,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(object b
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24143,6 +24935,7 @@ public ElasticsearchResponse<T> Mtermvectors<T>(string index, object body, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24176,6 +24969,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24211,6 +25005,7 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, objec
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24246,6 +25041,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24281,6 +25077,7 @@ public ElasticsearchResponse<T> Mtermvectors<T>(string index, string type, objec
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24316,6 +25113,7 @@ public Task<ElasticsearchResponse<T>> MtermvectorsAsync<T>(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24353,6 +25151,7 @@ public ElasticsearchResponse<DynamicDictionary> Mtermvectors(string index, strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24390,6 +25189,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> MtermvectorsAsync(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -24420,6 +25220,7 @@ public ElasticsearchResponse<T> NodesHotThreadsForAll<T>(Func<NodesHotThreadsReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24450,6 +25251,7 @@ public Task<ElasticsearchResponse<T>> NodesHotThreadsForAllAsync<T>(Func<NodesHo
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24482,6 +25284,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesHotThreadsForAll(Func<Nodes
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24514,6 +25317,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsForAllAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24546,6 +25350,7 @@ public ElasticsearchResponse<T> NodesHotThreads<T>(string node_id, Func<NodesHot
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24578,6 +25383,7 @@ public Task<ElasticsearchResponse<T>> NodesHotThreadsAsync<T>(string node_id, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24612,6 +25418,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesHotThreads(string node_id,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24646,6 +25453,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesHotThreadsAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24676,6 +25484,7 @@ public ElasticsearchResponse<T> NodesInfoForAll<T>(Func<NodesInfoRequestParamete
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24706,6 +25515,7 @@ public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(Func<NodesInfoRequ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24738,6 +25548,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(Func<NodesInfoRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24770,6 +25581,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24802,6 +25614,7 @@ public ElasticsearchResponse<T> NodesInfo<T>(string node_id, Func<NodesInfoReque
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24834,6 +25647,7 @@ public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, Func<Nod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24868,6 +25682,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, Func<N
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24902,6 +25717,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24934,6 +25750,7 @@ public ElasticsearchResponse<T> NodesInfoForAll<T>(string metric, Func<NodesInfo
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -24966,6 +25783,7 @@ public Task<ElasticsearchResponse<T>> NodesInfoForAllAsync<T>(string metric, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25000,6 +25818,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfoForAll(string metric, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25034,6 +25853,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoForAllAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25068,6 +25888,7 @@ public ElasticsearchResponse<T> NodesInfo<T>(string node_id, string metric, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25102,6 +25923,7 @@ public Task<ElasticsearchResponse<T>> NodesInfoAsync<T>(string node_id, string m
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25138,6 +25960,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesInfo(string node_id, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25174,6 +25997,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesInfoAsync(string node
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25204,6 +26028,7 @@ public ElasticsearchResponse<T> NodesShutdownForAll<T>(Func<NodesShutdownRequest
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -25234,6 +26059,7 @@ public Task<ElasticsearchResponse<T>> NodesShutdownForAllAsync<T>(Func<NodesShut
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -25266,6 +26092,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesShutdownForAll(Func<NodesSh
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -25298,6 +26125,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownForAllAsync(F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -25330,6 +26158,7 @@ public ElasticsearchResponse<T> NodesShutdown<T>(string node_id, Func<NodesShutd
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -25362,6 +26191,7 @@ public Task<ElasticsearchResponse<T>> NodesShutdownAsync<T>(string node_id, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -25396,6 +26226,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesShutdown(string node_id, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -25430,6 +26261,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesShutdownAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, data: null, 
 				requestParameters: requestParams
@@ -25460,6 +26292,7 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(Func<NodesStatsRequestParame
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25490,6 +26323,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(Func<NodesStatsRe
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25522,6 +26356,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(Func<NodesStats
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25554,6 +26389,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25586,6 +26422,7 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, Func<NodesStatsReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25618,6 +26455,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, Func<No
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25652,6 +26490,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25686,6 +26525,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25718,6 +26558,7 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, Func<NodesSta
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25750,6 +26591,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, Fu
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25784,6 +26626,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25818,6 +26661,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25852,6 +26696,7 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, Fun
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25886,6 +26731,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25922,6 +26768,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25958,6 +26805,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -25992,6 +26840,7 @@ public ElasticsearchResponse<T> NodesStatsForAll<T>(string metric, string index_
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26026,6 +26875,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsForAllAsync<T>(string metric, st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26062,6 +26912,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStatsForAll(string metric,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26098,6 +26949,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsForAllAsync(stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26134,6 +26986,7 @@ public ElasticsearchResponse<T> NodesStats<T>(string node_id, string metric, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26170,6 +27023,7 @@ public Task<ElasticsearchResponse<T>> NodesStatsAsync<T>(string node_id, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26208,6 +27062,7 @@ public ElasticsearchResponse<DynamicDictionary> NodesStats(string node_id, strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26246,6 +27101,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> NodesStatsAsync(string nod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26280,6 +27136,7 @@ public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, Func<
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26314,6 +27171,7 @@ public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26350,6 +27208,7 @@ public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26386,6 +27245,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26422,6 +27282,7 @@ public ElasticsearchResponse<T> PercolateGet<T>(string index, string type, strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26458,6 +27319,7 @@ public Task<ElasticsearchResponse<T>> PercolateGetAsync<T>(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26496,6 +27358,7 @@ public ElasticsearchResponse<DynamicDictionary> PercolateGet(string index, strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26534,6 +27397,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateGetAsync(string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -26569,6 +27433,7 @@ public ElasticsearchResponse<T> Percolate<T>(string index, string type, object b
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -26604,6 +27469,7 @@ public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -26641,6 +27507,7 @@ public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string t
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -26678,6 +27545,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -26715,6 +27583,7 @@ public ElasticsearchResponse<T> Percolate<T>(string index, string type, string i
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -26752,6 +27621,7 @@ public Task<ElasticsearchResponse<T>> PercolateAsync<T>(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -26791,6 +27661,7 @@ public ElasticsearchResponse<DynamicDictionary> Percolate(string index, string t
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -26830,6 +27701,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PercolateAsync(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -26860,6 +27732,7 @@ public ElasticsearchResponse<T> Ping<T>(Func<PingRequestParameters, PingRequestP
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -26890,6 +27763,7 @@ public Task<ElasticsearchResponse<T>> PingAsync<T>(Func<PingRequestParameters, P
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -26922,6 +27796,7 @@ public ElasticsearchResponse<DynamicDictionary> Ping(Func<PingRequestParameters,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -26954,6 +27829,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> PingAsync(Func<PingRequest
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"HEAD", url, data: null, 
 				requestParameters: requestParams
@@ -26984,6 +27860,7 @@ public ElasticsearchResponse<T> ScrollGet<T>(Func<ScrollRequestParameters, Scrol
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27014,6 +27891,7 @@ public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(Func<ScrollRequestParame
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27046,6 +27924,7 @@ public ElasticsearchResponse<DynamicDictionary> ScrollGet(Func<ScrollRequestPara
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27078,6 +27957,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(Func<Scroll
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27110,6 +27990,7 @@ public ElasticsearchResponse<T> ScrollGet<T>(string scroll_id, Func<ScrollReques
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27142,6 +28023,7 @@ public Task<ElasticsearchResponse<T>> ScrollGetAsync<T>(string scroll_id, Func<S
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27176,6 +28058,7 @@ public ElasticsearchResponse<DynamicDictionary> ScrollGet(string scroll_id, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27210,6 +28093,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollGetAsync(string scro
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27241,6 +28125,7 @@ public ElasticsearchResponse<T> Scroll<T>(object body, Func<ScrollRequestParamet
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27272,6 +28157,7 @@ public Task<ElasticsearchResponse<T>> ScrollAsync<T>(object body, Func<ScrollReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27305,6 +28191,7 @@ public ElasticsearchResponse<DynamicDictionary> Scroll(object body, Func<ScrollR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27338,6 +28225,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(object body, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27371,6 +28259,7 @@ public ElasticsearchResponse<T> Scroll<T>(string scroll_id, object body, Func<Sc
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27404,6 +28293,7 @@ public Task<ElasticsearchResponse<T>> ScrollAsync<T>(string scroll_id, object bo
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27439,6 +28329,7 @@ public ElasticsearchResponse<DynamicDictionary> Scroll(string scroll_id, object
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27474,6 +28365,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> ScrollAsync(string scroll_
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27504,6 +28396,7 @@ public ElasticsearchResponse<T> SearchGet<T>(Func<SearchRequestParameters, Searc
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27534,6 +28427,7 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(Func<SearchRequestParame
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27566,6 +28460,7 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(Func<SearchRequestPara
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27598,6 +28493,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(Func<Search
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27630,6 +28526,7 @@ public ElasticsearchResponse<T> SearchGet<T>(string index, Func<SearchRequestPar
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27662,6 +28559,7 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, Func<Searc
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27696,6 +28594,7 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, Func<Sea
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27730,6 +28629,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27764,6 +28664,7 @@ public ElasticsearchResponse<T> SearchGet<T>(string index, string type, Func<Sea
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27798,6 +28699,7 @@ public Task<ElasticsearchResponse<T>> SearchGetAsync<T>(string index, string typ
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27834,6 +28736,7 @@ public ElasticsearchResponse<DynamicDictionary> SearchGet(string index, string t
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27870,6 +28773,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchGetAsync(string inde
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -27901,6 +28805,7 @@ public ElasticsearchResponse<T> Search<T>(object body, Func<SearchRequestParamet
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27932,6 +28837,7 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(object body, Func<SearchReq
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27965,6 +28871,7 @@ public ElasticsearchResponse<DynamicDictionary> Search(object body, Func<SearchR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -27998,6 +28905,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(object body, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28031,6 +28939,7 @@ public ElasticsearchResponse<T> Search<T>(string index, object body, Func<Search
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28064,6 +28973,7 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28099,6 +29009,7 @@ public ElasticsearchResponse<DynamicDictionary> Search(string index, object body
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28134,6 +29045,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28169,6 +29081,7 @@ public ElasticsearchResponse<T> Search<T>(string index, string type, object body
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28204,6 +29117,7 @@ public Task<ElasticsearchResponse<T>> SearchAsync<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28241,6 +29155,7 @@ public ElasticsearchResponse<DynamicDictionary> Search(string index, string type
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28278,6 +29193,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SearchAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28313,6 +29229,7 @@ public ElasticsearchResponse<T> SnapshotCreate<T>(string repository, string snap
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -28348,6 +29265,7 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateAsync<T>(string repository,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -28385,6 +29303,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreate(string repository
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -28422,6 +29341,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -28457,6 +29377,7 @@ public ElasticsearchResponse<T> SnapshotCreatePost<T>(string repository, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28492,6 +29413,7 @@ public Task<ElasticsearchResponse<T>> SnapshotCreatePostAsync<T>(string reposito
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28529,6 +29451,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreatePost(string reposi
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28566,6 +29489,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreatePostAsync(st
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28599,6 +29523,7 @@ public ElasticsearchResponse<T> SnapshotCreateRepository<T>(string repository, o
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -28632,6 +29557,7 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryAsync<T>(string re
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -28667,6 +29593,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepository(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -28702,6 +29629,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"PUT", url, body, 
 				requestParameters: requestParams
@@ -28735,6 +29663,7 @@ public ElasticsearchResponse<T> SnapshotCreateRepositoryPost<T>(string repositor
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28768,6 +29697,7 @@ public Task<ElasticsearchResponse<T>> SnapshotCreateRepositoryPostAsync<T>(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28803,6 +29733,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotCreateRepositoryPost(str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28838,6 +29769,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotCreateRepositoryPo
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -28872,6 +29804,7 @@ public ElasticsearchResponse<T> SnapshotDelete<T>(string repository, string snap
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -28906,6 +29839,7 @@ public Task<ElasticsearchResponse<T>> SnapshotDeleteAsync<T>(string repository,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -28942,6 +29876,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotDelete(string repository
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -28978,6 +29913,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -29010,6 +29946,7 @@ public ElasticsearchResponse<T> SnapshotDeleteRepository<T>(string repository, F
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -29042,6 +29979,7 @@ public Task<ElasticsearchResponse<T>> SnapshotDeleteRepositoryAsync<T>(string re
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -29076,6 +30014,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotDeleteRepository(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -29110,6 +30049,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotDeleteRepositoryAs
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"DELETE", url, data: null, 
 				requestParameters: requestParams
@@ -29144,6 +30084,7 @@ public ElasticsearchResponse<T> SnapshotGet<T>(string repository, string snapsho
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29178,6 +30119,7 @@ public Task<ElasticsearchResponse<T>> SnapshotGetAsync<T>(string repository, str
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29214,6 +30156,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGet(string repository, s
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29250,6 +30193,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetAsync(string re
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29280,6 +30224,7 @@ public ElasticsearchResponse<T> SnapshotGetRepository<T>(Func<SnapshotGetReposit
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29310,6 +30255,7 @@ public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(Func<Snapsho
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29342,6 +30288,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(Func<Snaps
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29374,6 +30321,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29406,6 +30354,7 @@ public ElasticsearchResponse<T> SnapshotGetRepository<T>(string repository, Func
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29438,6 +30387,7 @@ public Task<ElasticsearchResponse<T>> SnapshotGetRepositoryAsync<T>(string repos
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29472,6 +30422,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotGetRepository(string rep
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29506,6 +30457,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotGetRepositoryAsync
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29541,6 +30493,7 @@ public ElasticsearchResponse<T> SnapshotRestore<T>(string repository, string sna
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29576,6 +30529,7 @@ public Task<ElasticsearchResponse<T>> SnapshotRestoreAsync<T>(string repository,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29613,6 +30567,7 @@ public ElasticsearchResponse<DynamicDictionary> SnapshotRestore(string repositor
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29650,6 +30605,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SnapshotRestoreAsync(strin
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29681,6 +30637,7 @@ public ElasticsearchResponse<T> Suggest<T>(object body, Func<SuggestRequestParam
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29712,6 +30669,7 @@ public Task<ElasticsearchResponse<T>> SuggestAsync<T>(object body, Func<SuggestR
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29745,6 +30703,7 @@ public ElasticsearchResponse<DynamicDictionary> Suggest(object body, Func<Sugges
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29778,6 +30737,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29811,6 +30771,7 @@ public ElasticsearchResponse<T> Suggest<T>(string index, object body, Func<Sugge
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29844,6 +30805,7 @@ public Task<ElasticsearchResponse<T>> SuggestAsync<T>(string index, object body,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29879,6 +30841,7 @@ public ElasticsearchResponse<DynamicDictionary> Suggest(string index, object bod
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29914,6 +30877,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -29944,6 +30908,7 @@ public ElasticsearchResponse<T> SuggestGet<T>(Func<SuggestRequestParameters, Sug
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -29974,6 +30939,7 @@ public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(Func<SuggestRequestPara
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30006,6 +30972,7 @@ public ElasticsearchResponse<DynamicDictionary> SuggestGet(Func<SuggestRequestPa
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30038,6 +31005,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(Func<Sugge
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30070,6 +31038,7 @@ public ElasticsearchResponse<T> SuggestGet<T>(string index, Func<SuggestRequestP
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30102,6 +31071,7 @@ public Task<ElasticsearchResponse<T>> SuggestGetAsync<T>(string index, Func<Sugg
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30136,6 +31106,7 @@ public ElasticsearchResponse<DynamicDictionary> SuggestGet(string index, Func<Su
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30170,6 +31141,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> SuggestGetAsync(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30206,6 +31178,7 @@ public ElasticsearchResponse<T> TermvectorGet<T>(string index, string type, stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30242,6 +31215,7 @@ public Task<ElasticsearchResponse<T>> TermvectorGetAsync<T>(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30280,6 +31254,7 @@ public ElasticsearchResponse<DynamicDictionary> TermvectorGet(string index, stri
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30318,6 +31293,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorGetAsync(string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"GET", url, data: null, 
 				requestParameters: requestParams
@@ -30355,6 +31331,7 @@ public ElasticsearchResponse<T> Termvector<T>(string index, string type, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -30392,6 +31369,7 @@ public Task<ElasticsearchResponse<T>> TermvectorAsync<T>(string index, string ty
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -30431,6 +31409,7 @@ public ElasticsearchResponse<DynamicDictionary> Termvector(string index, string
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -30470,6 +31449,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> TermvectorAsync(string ind
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -30507,6 +31487,7 @@ public ElasticsearchResponse<T> Update<T>(string index, string type, string id,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequest<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -30544,6 +31525,7 @@ public Task<ElasticsearchResponse<T>> UpdateAsync<T>(string index, string type,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return this.DoRequestAsync<T>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -30583,6 +31565,7 @@ public ElasticsearchResponse<DynamicDictionary> Update(string index, string type
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.Wrap(this.DoRequest<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
@@ -30622,6 +31605,7 @@ public Task<ElasticsearchResponse<DynamicDictionary>> UpdateAsync(string index,
 				ToNameValueCollection(requestParams);
 			}
 
+
 			return ElasticsearchResponse.WrapAsync(this.DoRequestAsync<Dictionary<string, object>>(
 				"POST", url, body, 
 				requestParameters: requestParams
diff --git a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
index 0558f583e90..eb40acab5b0 100644
--- a/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
+++ b/src/Elasticsearch.Net/IElasticsearchClient.Generated.cs
@@ -555,7 +555,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatAliases(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -574,7 +574,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatAliasesAsync(Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -630,7 +630,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatAliases(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/aliases/{name}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -650,7 +650,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatAliasesAsync(string name, Func<CatAliasesRequestParameters, CatAliasesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -703,7 +703,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatAllocation(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -722,7 +722,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatAllocationAsync(Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -778,7 +778,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatAllocation(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/allocation/{node_id}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -798,7 +798,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatAllocationAsync(string node_id, Func<CatAllocationRequestParameters, CatAllocationRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -851,7 +851,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatCount(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -870,7 +870,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatCountAsync(Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -926,7 +926,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatCount(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/count/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -946,7 +946,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatCountAsync(string index, Func<CatCountRequestParameters, CatCountRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -999,7 +999,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatHealth(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/health
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1018,7 +1018,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatHealthAsync(Func<CatHealthRequestParameters, CatHealthRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1071,7 +1071,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatHelp(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1090,7 +1090,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatHelpAsync(Func<CatHelpRequestParameters, CatHelpRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1143,7 +1143,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatIndices(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1162,7 +1162,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatIndicesAsync(Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1218,7 +1218,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatIndices(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/indices/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1238,7 +1238,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatIndicesAsync(string index, Func<CatIndicesRequestParameters, CatIndicesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1291,7 +1291,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatMaster(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/master
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1310,7 +1310,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatMasterAsync(Func<CatMasterRequestParameters, CatMasterRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1363,7 +1363,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatNodes(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/nodes
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1382,7 +1382,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatNodesAsync(Func<CatNodesRequestParameters, CatNodesRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1435,7 +1435,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatPendingTasks(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/pending_tasks
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1454,7 +1454,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatPendingTasksAsync(Func<CatPendingTasksRequestParameters, CatPendingTasksRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1507,7 +1507,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatRecovery(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1526,7 +1526,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatRecoveryAsync(Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1582,7 +1582,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatRecovery(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/recovery/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1602,7 +1602,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatRecoveryAsync(string index, Func<CatRecoveryRequestParameters, CatRecoveryRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1655,7 +1655,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatShards(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1674,7 +1674,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatShardsAsync(Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1730,7 +1730,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatShards(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/shards/{index}
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1750,7 +1750,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatShardsAsync(string index, Func<CatShardsRequestParameters, CatShardsRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
@@ -1803,7 +1803,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		ElasticsearchResponse<DynamicDictionary> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null);
+		ElasticsearchResponse<string> CatThreadPool(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a GET on /_cat/thread_pool
 		///<para></para>Returns: Task that'll return an ElasticsearchResponse&lt;T$gt; holding the response body deserialized as DynamicDictionary
@@ -1822,7 +1822,7 @@ public interface IElasticsearchClient
 		///<para> - can be safely dispatched to a nullable type even if intermediate properties do not exist</para>
 		///</returns>
 		
-		Task<ElasticsearchResponse<DynamicDictionary>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null);
+		Task<ElasticsearchResponse<string>> CatThreadPoolAsync(Func<CatThreadPoolRequestParameters, CatThreadPoolRequestParameters> requestParameters = null);
 		
 		///<summary>Represents a DELETE on /_search/scroll/{scroll_id}
 		///<para></para>Returns: ElasticsearchResponse&lt;T&gt; holding the reponse body deserialized as T.
diff --git a/src/Nest/DSL/Paths/BasePathDescriptor.cs b/src/Nest/DSL/Paths/BasePathDescriptor.cs
index 815420c382b..695481db2e5 100644
--- a/src/Nest/DSL/Paths/BasePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/BasePathDescriptor.cs
@@ -7,12 +7,12 @@ namespace Nest
 	public class BasePathDescriptor<T>
 		where T : BasePathDescriptor<T>
 	{
-		internal IRequestConfiguration _RequestConfiguration { get; set; }
+		internal RequestConfiguration _RequestConfiguration { get; set; }
 
 		/// <summary>
 		/// Specify settings for this request alone, handy if you need a custom timeout or want to bypass sniffing, retries
 		/// </summary>
-		public T RequestConfiguration(Func<RequestConfiguration, IRequestConfiguration> configurationSelector)
+		public T RequestConfiguration(Func<RequestConfiguration, RequestConfiguration> configurationSelector)
 		{
 			configurationSelector.ThrowIfNull("configurationSelector");
 			this._RequestConfiguration = configurationSelector(new RequestConfiguration());
diff --git a/src/Nest/DSL/Paths/DocumentPathDescriptor.cs b/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
index 2a8cb155989..e89e27b22c8 100644
--- a/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/DocumentPathDescriptor.cs
@@ -90,7 +90,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Id = id
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs b/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
index c890e219895..954b9100fef 100644
--- a/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/FixedIndexTypePathDescriptor.cs
@@ -66,7 +66,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo(IConnectionSettingsValues s
 				Type = type
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs b/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
index 0c7b79e0a2e..8fd31e224b1 100644
--- a/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexNamePathDescriptor.cs
@@ -62,7 +62,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Name = this._Name
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs b/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
index c13ae9f4089..4cea99668e6 100644
--- a/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexOptionalPathDescriptor.cs
@@ -66,7 +66,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexPathDescriptor.cs b/src/Nest/DSL/Paths/IndexPathDescriptor.cs
index d2663e49bf9..cb508399aec 100644
--- a/src/Nest/DSL/Paths/IndexPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexPathDescriptor.cs
@@ -54,7 +54,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs b/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
index c9e2c096339..87bc81880ef 100644
--- a/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexTypePathDescriptor.cs
@@ -79,7 +79,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Type = type
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs b/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
index f2251d6f5cc..1fa1a1c4701 100644
--- a/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndexTypePathTypedDescriptor.cs
@@ -79,7 +79,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Type = type
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
index 5db07450e2d..e984953c041 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalExplicitAllPathDescriptor.cs
@@ -71,7 +71,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
index de0a4cfd7b9..c1bf2f33be4 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalPathDescriptor.cs
@@ -56,7 +56,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Index = index,
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs b/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
index 94e1caf69aa..ddf4faccd6f 100644
--- a/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesOptionalTypesNamePathDecriptor.cs
@@ -140,7 +140,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Name = this._Name
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs b/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
index dcd4ce601d1..f58120fd2cb 100644
--- a/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/IndicesTypePathDescriptor.cs
@@ -90,7 +90,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Type = type
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/NamePathDescriptor.cs b/src/Nest/DSL/Paths/NamePathDescriptor.cs
index 5d6983d520b..b4d65fb696b 100644
--- a/src/Nest/DSL/Paths/NamePathDescriptor.cs
+++ b/src/Nest/DSL/Paths/NamePathDescriptor.cs
@@ -44,7 +44,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				Name = this._Name
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs b/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
index 9e365586af6..56c8d17ea88 100644
--- a/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
+++ b/src/Nest/DSL/Paths/NodeIdOptionalDescriptor.cs
@@ -41,7 +41,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 				NodeId = this._NodeId
 			};
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Nest/DSL/Paths/QueryPathDescriptor.cs b/src/Nest/DSL/Paths/QueryPathDescriptor.cs
index c4363b02698..a67ebe76a4d 100644
--- a/src/Nest/DSL/Paths/QueryPathDescriptor.cs
+++ b/src/Nest/DSL/Paths/QueryPathDescriptor.cs
@@ -139,7 +139,7 @@ internal virtual ElasticsearchPathInfo<K> ToPathInfo<K>(IConnectionSettingsValue
 
 
 			pathInfo.RequestParameters = queryString ?? new K();
-			pathInfo.RequestParameters.RequestConfiguration(this._RequestConfiguration);
+			pathInfo.RequestParameters.RequestConfiguration(r=>this._RequestConfiguration);
 			return pathInfo;
 		}
 
diff --git a/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs b/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
index 9c00a9d5346..cf6452f5eac 100644
--- a/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
+++ b/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Collections.Specialized;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Net;
 using System.Runtime.Remoting.Channels;
@@ -22,7 +23,7 @@ public class YamlTestsBase
 		protected static readonly Version _versionNumber;
 		
 		protected object _body;
-		protected ElasticsearchResponse<DynamicDictionary> _status;
+		protected IElasticsearchResponse _status;
 		protected dynamic _response;
 
 		protected static ElasticsearchResponse<string> _x; 
@@ -49,7 +50,7 @@ public YamlTestsBase()
 			_client.IndicesDelete("*");
 		}
 
-		protected void Do(Func<ElasticsearchResponse<DynamicDictionary>> action, string shouldCatch = null)
+		protected void Do(Func<IElasticsearchResponse> action, string shouldCatch = null)
 		{
 			try
 			{
@@ -81,7 +82,11 @@ protected void Do(Func<ElasticsearchResponse<DynamicDictionary>> action, string
 				Assert.IsTrue(Regex.IsMatch(Encoding.UTF8.GetString(this._status.ResponseRaw), re),
 					"response does not match regex: " + shouldCatch);
 			}
-			this._response = this._status.Response;
+			if (this._status is ElasticsearchResponse<DynamicDictionary>)
+				this._response = (this._status as ElasticsearchResponse<DynamicDictionary>).Response;
+			
+			if (this._status is ElasticsearchResponse<string>)
+				this._response = (this._status as ElasticsearchResponse<string>).Response;
 		}
 
 		protected void Skip(string version, string reason)
@@ -225,6 +230,7 @@ private static object Unbox(object o)
 			if (o is JArray) o = ((JArray) o).ToObject<object[]>();
 			if (o is JObject) o = ((JToken) o).ToObject<Dictionary<string, object>>();
 			if (o is ElasticsearchResponse<DynamicDictionary>) o = ((ElasticsearchResponse<DynamicDictionary>)o).Response;
+			if (o is ElasticsearchResponse<string>) o = ((ElasticsearchResponse<string>)o).Response;
 			return o;
 		}
 
diff --git a/src/Tests/Nest.Tests.Unit/Core/Domain/Connection/ConnectionTests.cs b/src/Tests/Nest.Tests.Unit/Core/Domain/Connection/ConnectionTests.cs
index 6dc920f284e..2988246e8f1 100644
--- a/src/Tests/Nest.Tests.Unit/Core/Domain/Connection/ConnectionTests.cs
+++ b/src/Tests/Nest.Tests.Unit/Core/Domain/Connection/ConnectionTests.cs
@@ -16,7 +16,7 @@ public TestConnection(IConnectionSettingsValues settings)
 
 		public HttpWebRequest GetConnection(string path, string method)
 		{
-			return base.CreateHttpWebRequest(new Uri(new Uri("http://localhost"), path), method);
+			return base.CreateHttpWebRequest(new Uri(new Uri("http://localhost"), path), method, null);
 		}
 	}
 

From 394d90d335ac08d569d06357418bc4c7d5aebc1f Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 14:09:17 +0200
Subject: [PATCH 16/20] fixed nullref causing elasticsearch.net unit tests to
 fail

---
 src/Elasticsearch.Net/Connection/Transport.cs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/src/Elasticsearch.Net/Connection/Transport.cs b/src/Elasticsearch.Net/Connection/Transport.cs
index 904eaa3e505..d5df1726a9b 100644
--- a/src/Elasticsearch.Net/Connection/Transport.cs
+++ b/src/Elasticsearch.Net/Connection/Transport.cs
@@ -103,7 +103,6 @@ public IList<Uri> Sniff()
 				using (response.Response)
 				{
 					return Sniffer.FromStream(response, response.Response, this.Serializer);
-					
 				}
 			}
 		}
@@ -138,7 +137,7 @@ private void SniffIfInformationIsTooOld(int retried)
 		private int GetMaximumRetries(IRequestConfiguration requestConfiguration)
 		{
 			//if we have a request specific max retry setting use that
-			if (requestConfiguration.MaxRetries.HasValue)
+			if (requestConfiguration != null && requestConfiguration.MaxRetries.HasValue)
 				return requestConfiguration.MaxRetries.Value;
 
 			return this._configurationValues.MaxRetries.GetValueOrDefault(this._connectionPool.MaxRetries);
@@ -260,7 +259,6 @@ private ElasticsearchResponse<Stream> _doRequest(string method, Uri uri, byte[]
 			throw new Exception("Unknown HTTP method " + method);
 		}
 
-
 		/* ASYNC *** */
 		public Task<ElasticsearchResponse<T>> DoRequestAsync<T>(string method, string path, object data = null, IRequestParameters requestParameters = null)
 		{

From 61b7de739d4f6ceea246a7f4e035846273b9146f Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 14:10:17 +0200
Subject: [PATCH 17/20] spacing cleanup in yaml test base

---
 .../Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs     | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs b/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
index cf6452f5eac..6f7c545499c 100644
--- a/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
+++ b/src/Tests/Elasticsearch.Net.Integration.Yaml/YamlTestsBase.cs
@@ -1,16 +1,11 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Collections.Specialized;
 using System.Diagnostics;
-using System.IO;
 using System.Linq;
-using System.Net;
-using System.Runtime.Remoting.Channels;
 using System.Text;
 using System.Text.RegularExpressions;
 using Elasticsearch.Net.Connection;
-using Elasticsearch.Net.Connection.HttpClient;
 using Elasticsearch.Net.JsonNet;
 using Newtonsoft.Json.Linq;
 using NUnit.Framework;
@@ -357,6 +352,7 @@ private static void SerializedArrayJsonEquals(object value, object oo)
 			var nOtherJson = JArray.Parse(Encoding.UTF8.GetString(otherJson)).ToString();
 			Assert.AreEqual(nJson, nOtherJson);
 		}
+	
 		private static bool SerializedJsonEquals(object value, object oo)
 		{
 			var json = _client.Serializer.Serialize(value);

From c917173c05bd44ada18cf505b47a222ee6f31471 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 14:26:41 +0200
Subject: [PATCH 18/20] updated autofac/fakeiteasy

---
 dep/Autofac.3.2.0/Autofac.3.2.0.nuspec        |   17 -
 dep/Autofac.3.2.0/lib/net40/Autofac.dll       |  Bin 200704 -> 0 bytes
 .../portable-win+net40+sl50+wp8/Autofac.dll   |  Bin 200704 -> 0 bytes
 dep/Autofac.3.3.1/lib/net40/Autofac.dll       |  Bin 0 -> 201728 bytes
 .../lib/net40}/Autofac.xml                    |   39 +
 .../portable-win+net40+sl50+wp8/Autofac.dll   |  Bin 0 -> 201728 bytes
 .../portable-win+net40+sl50+wp8}/Autofac.xml  |   39 +
 .../lib/net40/Autofac.Extras.FakeItEasy.dll   |  Bin 11776 -> 11776 bytes
 .../lib/net40/Autofac.Extras.FakeItEasy.xml   |    0
 .../lib/net35/FakeItEasy.dll                  |  Bin 645120 -> 0 bytes
 .../lib/net35/FakeItEasy.xml                  | 3540 -----------------
 .../lib/net40/FakeItEasy.dll                  |  Bin 646656 -> 0 bytes
 .../lib/net40/FakeItEasy.xml                  | 3525 ----------------
 dep/FakeItEasy.1.15.0/lib/sl40/FakeItEasy.dll |  Bin 473088 -> 0 bytes
 dep/FakeItEasy.1.15.0/lib/sl40/FakeItEasy.xml | 3424 ----------------
 dep/repositories.config                       |    1 -
 .../Elasticsearch.Net.Tests.Unit.csproj       |    7 +-
 .../packages.config                           |    5 +-
 .../Nest.Tests.Unit/Nest.Tests.Unit.csproj    |    4 +-
 src/Tests/Nest.Tests.Unit/packages.config     |    2 +-
 20 files changed, 87 insertions(+), 10516 deletions(-)
 delete mode 100644 dep/Autofac.3.2.0/Autofac.3.2.0.nuspec
 delete mode 100644 dep/Autofac.3.2.0/lib/net40/Autofac.dll
 delete mode 100644 dep/Autofac.3.2.0/lib/portable-win+net40+sl50+wp8/Autofac.dll
 create mode 100644 dep/Autofac.3.3.1/lib/net40/Autofac.dll
 rename dep/{Autofac.3.2.0/lib/portable-win+net40+sl50+wp8 => Autofac.3.3.1/lib/net40}/Autofac.xml (99%)
 create mode 100644 dep/Autofac.3.3.1/lib/portable-win+net40+sl50+wp8/Autofac.dll
 rename dep/{Autofac.3.2.0/lib/net40 => Autofac.3.3.1/lib/portable-win+net40+sl50+wp8}/Autofac.xml (99%)
 rename dep/{Autofac.Extras.FakeItEasy.3.0.1 => Autofac.Extras.FakeItEasy.3.0.2}/lib/net40/Autofac.Extras.FakeItEasy.dll (92%)
 rename dep/{Autofac.Extras.FakeItEasy.3.0.1 => Autofac.Extras.FakeItEasy.3.0.2}/lib/net40/Autofac.Extras.FakeItEasy.xml (100%)
 delete mode 100644 dep/FakeItEasy.1.15.0/lib/net35/FakeItEasy.dll
 delete mode 100644 dep/FakeItEasy.1.15.0/lib/net35/FakeItEasy.xml
 delete mode 100644 dep/FakeItEasy.1.15.0/lib/net40/FakeItEasy.dll
 delete mode 100644 dep/FakeItEasy.1.15.0/lib/net40/FakeItEasy.xml
 delete mode 100644 dep/FakeItEasy.1.15.0/lib/sl40/FakeItEasy.dll
 delete mode 100644 dep/FakeItEasy.1.15.0/lib/sl40/FakeItEasy.xml

diff --git a/dep/Autofac.3.2.0/Autofac.3.2.0.nuspec b/dep/Autofac.3.2.0/Autofac.3.2.0.nuspec
deleted file mode 100644
index cfd6341f879..00000000000
--- a/dep/Autofac.3.2.0/Autofac.3.2.0.nuspec
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0"?>
-<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
-  <metadata>
-    <id>Autofac</id>
-    <version>3.2.0</version>
-    <title>Autofac</title>
-    <authors>Autofac Contributors</authors>
-    <owners>Autofac Contributors</owners>
-    <licenseUrl>http://www.opensource.org/licenses/mit-license.php</licenseUrl>
-    <projectUrl>http://autofac.org/</projectUrl>
-    <iconUrl>http://code.google.com/p/autofac/logo</iconUrl>
-    <requireLicenseAcceptance>false</requireLicenseAcceptance>
-    <description>Base assemblies for the Autofac Inversion of Control Container</description>
-    <summary>Autofac is an IoC container for Microsoft .NET. It manages the dependencies between classes so that applications stay easy to change as they grow in size and complexity.</summary>
-    <language>en-US</language>
-  </metadata>
-</package>
\ No newline at end of file
diff --git a/dep/Autofac.3.2.0/lib/net40/Autofac.dll b/dep/Autofac.3.2.0/lib/net40/Autofac.dll
deleted file mode 100644
index a4cdaf101da51c7fda5a864bdcb782ed59b32eca..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 200704
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%0Dy!-XW7K6FMNgxAyq9vESpTr8Z3ZWa%JRBi$|
z9<tmzeDUWK-74=hXOq`qGv+0{rXJ*VfdcBl!infD%Ig~>wTM<7q?Y7Dkg0=<TpFEF
zQrfz})%E$M61VKjXwhvec56%cdup^d)|QUst!U2(Z%U1Qf8%r7>nw&{&8<8+M{ZW+
z^ZYvA9M-stb`Cb)g%8_bP`wVzLI+jW_B2Kv_KM%8oV<rp#c$K_S?kIO#ltzmnOWl0
zhVkB%!=hR)jvMyZ>+uefB%jt}4?Y`fc=#afskjK+V5gVEy5P=kxjnni#!FmsnGDRy
zTqbg3t!RB=gD-ZXj0pl;o-V{2$jw}bW6RwN@y7wQdI}f6A#_LE=+QCInMiK+>!@Tw
z2crt{J4qF2o8L`<qN9<o9XN>h607Q84yXM4sr=u;PU*aW5KDeTB-q3LU0JXFp>O-~
zN{&nkG7L2KmKby*tuPv2&uVDscHg;vix%XOj=kVB&GI_8*Eu3q@W7QhV)A1AOANNr
zP_DyG;RpD%Eop3v!`juVBR9}F_-^+@+>_3UhFG&lqpgp1!uuHMa>q;Bq?JVL7Kc+E
zIX0S?P%4`ueNZ{lua>6-GI(?hIg4&B+Lws57FzP}vW1tDtkn*WA)9Fweg?ZEyrv$s
z!$}3SLklOO55vRcUrA~ancXqyj+G8*rUO~X7Lfg5k^0}Cz^WbvRlQ?XbylR396-ci
zpWk>UAueg5_Z1pK_v;7h!zjd;FfNHc0VCxQ$M8W!BrlO#ER-0I<H6wQV4$TN*G7jB
z4wQOF;zN1qwT|;J-gJmdOTE^wzl-ph%Kva7v)cA7;TCjAzTCNv+^eeq$~2i{DQmU_
zC+x|!0HOoY(B%#%J`!j-WTovWUQBHh+znxW?=(}Dob@T?wy+!xYU3ClKIx8Cx>k$s
ztqb0&SbVr|q*VmbClP}yN1%Nn9vy5YxeGqDm&Q<RZ!Z?&M`}JFmz)^Kq-77Z_r{|`
zWIihw^W-%YBRkkS7+!WGtojiHNwm9_H!=%7dIaxaOLw<stxC-9D<!v`w__{aM+!O)
z-i_Gk4cOHl+d6wZF!uN}G_A!as%#F|Vd!{c-7tFX3JbFjv|;TRsw5Mj%RWAvP!-g6
zc!YJqa<w7bcoLxGWF9(?QCr@=+Tqr0EoV~O58PVg<>)($kH1oVGD)p9u5b;Yewjjz
zQtc(vYJBVKRS|`lewdojSWLc{L&fJ$T|Lx|W?h8*=(9*FVVn^*l+L#}c)VM+LjlXC
zCHdo)?XC6XeJZ73JXu#5M5n1tvq*W%)>M?qXe_PIJPH$94r_&DvkDIJCBh!97B<b(
zi_Y%bhOB9Q*=d{3evLBa&&RzPw)5xX=$W^0K92sZlKhOEwZ0^@PE*@g7p(hy9985j
z(o-G!ZJm#6Ak*~BIdiw%`8aXeJ|B0Fq}#R;i>Oz3$HiT0K3QFE&;$UHb{ydqpnWbk
zIi1hUZeX+2XH}9j0II(_laP*z`D!^in}<#vcAjrLM;O{oU5-vBj;@2Th|ags3|z50
z&g-gpE%w^GBA-io4LJ#j)$VZ%({DFLfVYk@*c7B%w!d#Kwjb@D!S)NUsRy<niJ9%U
za3Y$Pg=mn}A~M@=&@XpFGl_Qba8;g%ZHC|h0nNaJ@S1wS!%I^hEM&Kdc=$L;E#fK0
zoG;7g^(W<pz-P!ycuhUX>*Z-)7EVMzS6(k3CNBZH$DHT6N_bu>e0{1i?Aw)_I_=n-
z`U6O{_NEHIV{hvH`B+hT+Iv%R>acg=jkMm}-c->K>w0$XO%-K3%TS(qZ|b+s{Pg9m
zEvR>5kbFnvTfBDfO%<)y-qftlvrrDAchCxL-$Zr9XWCmmI|yvUp<ib(Scu;*d-r^Z
zR9U9Rvrb;`5_}zSru8viBsNbf!cKW)?GAhHF=ns$sqNT<aRYtOKlPv=FYmzs+uTYI
z(d^Bwlt$7yI!bomOheqs=VS>XUT%o1K-X&2<QMv-ti}c8t}7~Pd)!NP792KyAuF0v
z@~&jj187Tssd+U>Hd=d_Z#(EcC6K|R=Rjx8>qMtyCtLP-1@FltW+E%a1|!TuU!i1j
zX-E<&FR7pEVexYj{FtALIem@c&!YlfEGF@u)SB01**~J}8HSdp1TuJZCK%>VAL!+R
zmR)8Q`%K=)&MNe}O+d2>=|&(;6x7+t*W}y{?^YRq0a5jFMUUa2$KbJ&JVyQl1%H)a
ztopXS7<bV3Nj=_MuuoR`gXlrh*;jvWso12@PDGE2$4kYdKn9P_g2#q3)7a^86)sWX
z&KB#t@MxLC(*rw$>DO-o*<S6Y9qLhI%4P7!P@|GO0SS#2gyqLyfHQjAUx{v=_voBF
z$xpG+aXGn}7L9N1*Kf^8XAxT|4dWi|>DCemPNj17I$m1I#^$DAE3fXs@r9d-GC+2u
zw?9WeBP|8wT@)>8^F3s4n#8g7R7?UH+{Bbthm{u{^O#aqk|#m#XVN6r13IH$EAa~?
z!sk-d=CzsZACv4~2z*K)gX=_aO=m>um(0`Hye`9jT-c&AC6K|59vS>b8Hi9jd8>|C
z9QwS3bvU-*y^^IGO!P~LQCilEir$qpRpv0ZU$ZnX8&qqKI^O#7<+d%4FLm=L7Rl4e
zr@I3qH}4GGdd%t}wf}PRI}?Rln{h2(Je1m;IJ)V!=TeKVn%9U!)1ho;6y@YW9_#W+
zrQ>4<`Z<tk`I?(4m}4}ApquE)260^nH;rUei#e)(^Oc#HpOBcP?^6O9Tt_8q?hyCy
zC246b!v<NB@f9wk-gZX1^oxwbRz~@0xm%7}^9$CD^D9!eX6(Z@Hq~2(=xC8{k%I5@
z{b0p#dYAxPEDIW#f6~?+iXMHB^B)HhUYAfKynS00=jywo_I^eQ+pdESuK^<(rbgzt
zvC!<yR7StG-D69>i$cuwpUu<SQXf4;Hkte4N!~A`e13-y<F6fz#6s%i1{W&az!a09
z_8=_l-2&$IZ-zJhMRjV-uYVBbs((NaOX$Ae$9FzT#A2rJ__y2m2E?KQ{1EuoN@y`%
z2+TXe=(q5>Sq$?FcLp_$c|Sy=uL5+o`a|$|tZc&{P$1opCMN&8D+CTy5O+qQZaiKL
z&E6|jrrs+pllx(3?5O0A*3x<#;<yyJwx*K!F4>b{mD)wK&b&-lx&m#&g8WH(y%X=w
zkK%5^%LKho;11N+@iDO2R6QJ`AK|s_K(cwyL6nh(T1ozFtoRL~Gb9%(S^Py=U~81!
zU-jPLJz2pUcQCvc-N2TF8+r@T^J!Ok7moZlj6`$(o4-+*1vk({dbHcLEthnMDVI!`
zs8nXtI{IL#*8J43(-LX(RS4JY`yW7cejR}f{=fNkZX#K0Z2xSU-!$f7hOw^jntCwS
zeYFDoIu=eue}ace^WX@OjqMHkCkPsP=V)6_&5t5oE!m;{_Bti0?yb`Z=F~)P8Y@f@
z;%})Wf0MjBJu0&F6C*9V-(f4*tTDsoSr4Kp>%zdCu|aZ?RR7Zw;7iE6AucrK|GVlq
z0yA}o3f}6K#QDd>`Blcby}neO{~9_e=i)no?-RuLKW66p;uhaBd)KwT!osXV^iOD6
z{o@a|kK|Y4(pY_&SXH)S^`Bj=3QmVPUUEl}s)64%9Y?0QJ;1M_x>|Mr33!-h95_SW
z3$LjMb^lrg)V+lh(Z6AA@{mz#S%A)3?#PRgYdf!NNicopjCl#KsRwzzUIBSoI1zCp
zVmR41pS%Rf^vs}V%m{t$jL^qBp_#Ghns2^=ELyS|T>!sl&B(9tntH%5{kQRJ;Y7sw
z&2aMlB((^~FKh1HnYA87YrgY9aRYsU3?9t}rfuOGN3*w`<KLG=YcVYiW@%bZwJ{rZ
zhufOmS+2WV7lsCxQwyzK=;OzQ@wggP4N7ANxsPecy2~}<m!nGKD^i@R^|2J!Aep3~
zYXIT+3Cz|;=flES>#9-FjlN6+>i46$FwC;0g{Alvq#8AMHg>TTT|lx8z3x)l`kPb&
z`N8aEVYE<1ZB;;rzR*Fo<v)xJrWtO}pqs*L>Vf><q5yrda3UIo`s5c#Y7tKU-|~}d
zVX*O5Q2pdOy<%>7eWhOCuGeXdZhFm<ECdAW!d56$g~F?P0doahPWG2A>Dg@-(S@q6
z>!FA@aEC?IAB1XJRxSHQyWv7tLev^J0+>~>nLI{dPY~0+sIv-<R}rVIL`9(zD^wbV
z7SCGgQ}b{W*d08)T7WzcuK}<n9$uT~B`V5Oi4_|B;vi#O_h+;=(OTT@eqifZy35#7
zC>QDU80G?<K2kE-Q6fN(O`;aA2Z1_s_v7dYh95mCJFJ<L9lp?g$mQyJ%nEDZQLwW_
zC>EjjS(R9yLA$Vf7S%trJ)p9)`O8I=K(}5%u^f)4t5f$=;ckd2KeKVuaq(hUT?hNB
zDLZarXJs5OLF4`6;4e>|=?B0W>yP$?d$%8f-I{{=bxVzGKPW0{BKGo&U~JsMxCPa4
zE-#>+WApvGl8w)Cz{>=*O^k@9ij1ix=gRA7Qy(Hp%cfmJA*N}aGqfq;HT9rPeOLi)
z%EF0gwc6B@t!PsMblUsV{rdl@W2%3gXV(~u2B5a0JC*)Lr=@$Sgez&ak0g~WeMhZ1
zkS*J|!JPHor7M+%-B`k@BsatPxB9~0pef~W^HWLj%~BkA&|aghY2Y|8ZQj_{53$m2
zf`L_SIoxJAej`bnAEC5nvG-Heok=!R0vSAa5o&QYYUQyh5M!mSMa+s>6^h>kiLw6P
z7`J_S4}2<KZ;X?<JT}-H<Hs&r{P<*VL_LOMvwLk0&%tOV8$Y!azm<?pjK{JkX{j&{
zEsex)12)*FYjubFK&AVzd&ivNTD2V2Aaeeyaw!;&-!3{sq%M+rh@owzFdXBA%FcJL
zd6wIF)Oo}+-T!xj_xU+)Z&9XGXz53tR@6VPP%`}-g~B1r{ub-DMjMKusT_x@=;oVR
zLrK&IPXgksMX{r%gY?E=wrk#i*cLTDMuL(4+F4;~{lLhetpV%&@%C)o!r5hxtlr|>
zq7JXJKEbdIe2%DY7#*zjWrvLKV#8H#J5}HKZ0?dU)_NPC0KZxqJ*mG$mMh<s?O{F3
z+vPRcp3S1ykFK0-<vM_hXOqjr<d!yF%MotXUzFi=I4q@HtdH@)u|g%{4nz(QHvf+t
z{b+v(&GlpaRAu}`_8A=lY#<lk8{>20>ggC)4Es*+dpY7AbTjrxU?6o3*o@r>Xxi>b
z#rS!g#RO)ag1#8nMLBsjS*#l>Y(_-qv|Umi*4~_mJG)&eI0BU-a>5>a-sRq`mwE@j
zfU?{B*S-Bqyld=xJh7*=Wma`rKHB2j<~~vfR;>NHsv%o@c9_2evu%V;*HR-av&J14
z>D=@)<a4U>ahfv?Nw)?yIVG*b+;EtP`dJ8HXi)9UzU$B8HDV5m_Jn=zGU}nC?k!_R
zYFC<7iV=eet~2ZHtLT1L*L1h7aJjycMNEG=RZb))yrU2D!P)i?5pap$NrQb-r1i8j
ztcz|t?o03J>#y`{d8t3Tl!h?Gt!yzfOs@S;K0+`ht;jFhUDs+L^a7t$B(AW-p;&z+
zh^0L4?zT@8V;1QsKnatS@{~YLJ)%i6^6N?*CA^A)I#D;Lr<3zeLvFHoZ);_y-ICl1
z&N?roqRU7XUCzT@)KK7_hH4O90f07eywDzm9zP!N0zi(dmg4oN(^X~P{1gvk^GGGa
z=9i}gGI;bt<#MbZ`w}sL_{Ntx9XJ7Or{&!ArwiP<Ceiu5ZX#x#LpqUHrzqxjvuhBK
zgDrP6cV@0S=R7D)yAQmR(oa(<GxUMNYwAHC_*n(?ffi0g$B^yh+O6pW1<2+h27T*{
z(EGZe+1S4E2}+HZ=#vD{uj^BxeY^R{iPY6L)Kzvz$?V0sbs*t)tOM<sj}?`ty$-~r
zpLHN=EWZvU`k`^vxeg@Cp>a9$I?&xWZ~dLFbs&+N@s1MF+H4)@INxt;`i*OoPk|&I
zW(Leg!oWhm4pd$p;GYqkdJesRATL%oDoLS;MeWjX)GO6^R?<;k^`3=5n%%sOnlv@#
zkX4x6M)Z_G29I8ZhGLAHbaD>qWFdV{NCFu=S_e`?ENStfNbboOK#1yqo1f1To}z@e
zE1^IJkFJ#dtEu&~=>&#KFy!=msAV!~1ie;XvtTp_klL-TqiM9%-p0brRP=ia?5m!X
zi`)j?*?{#6u)r94ElQ(%{cDXc3Q(N9L4cY7w+k?<F!@PAE*9iV1}RS7--3Ku5WlX7
z`8Py1{Txa5rkq&!<X4mc<Nkal{fa}hOzO&8b}Ve*YqS}F;8K3&sXA4E>+BUdcxOsK
zslE1it$RE#I#lo~C%UzyPJ2mt<bBH!k31cYGHUte&6==%&#x<ebSBBlVe<~&O&iYU
z+YI8AKn8D{M%5SFxx(lSVL3|1eknc-2;;s32{<YeL}&5RS7nt;rP3x{tzX<ox#*D6
zwjDITmgRa5NG?}_3~sr`Uqo{TYKwZ~FY&_t<zFUP&Usn&iEec`z1`$KJ4}$?ZQ>+y
zJ~+<zh%%*8(C=cXCN}iV4^t&V5!~68oxB|;oGU-msH5<G(E^bb?X8eJ6N2VHT}e64
zRyjhnUh8Fw4nb3mySi7hA`YvP+QnDkI%=R2s^)ZHt}*0KpmUCNwJx2CnqY8n$Bo3Z
zarm9YSj{|FGD0iLQvx;huyJ_wVv^xg6bWq`)Tx~d>Blu>L}FhRB&_W}muqr(rH+n<
z#$eyrP9=9IYBWW9u19gh$^~I>{59~F_cCU-L7f{o*ZLrEClTYH+Bj=&xM>8XTI5b0
zXD5PQ$<VWNK<)PJpY0v>QEwJS#YK6H_o8pQv1TUYj``ZxDMM?%*0&9P72Wa-eU<Q<
zdeB#WLjir2g%i<vh-va#l3GO8R~huPolu(Ix0F_MPkU+l(c?5wW|S8~1Vdq-sFxs~
z#y4Fi(FIZg>`Y+mlFy~?*e6LVZBOacO51JLuPbE`e;vuWi5r8CST)%>aa*A~7Sdt1
z`oTW$Ey(L!>4tM5XlXrcd>dkZUC-uyJf>foNvHW;K21$tCF1)_O$0J{va?`s<uN)k
z{|4V#tZBwEPO>(^#CElB+f5<%Ge~w1kzI$0%~Q_F1_(92!<!CVD~u<B=)AK&f;j2;
z!mVqEsx7V%U#`zA-4*$d7jz_hVaL~tI=<F*eAPR?uI%_~=!<$5-#XcyGNJpGt5*kO
zSOw#ME#h)W9WI5#UG!xk79xnhK^00@qHpSDxpqK*OK;SZ<^X#Wo@e#-9iU~dk0Tfx
zb73r4zcWkosc2`Y-7*T-MfKW1uZ(8VsHiLkh~D#{6^tFMW0l{B`(*>^vC0|;AigJ|
ze^=SKgPbYkdq75Ze!w4Y2*J*srAHz&Ckb?&tt)zK_HCc7S`B;`<%jOJJpwv8XIZz-
zLt4f`{C)E2I1K4%&hfS$cQm<J44-1z*hr7sh>%m|>H*5;QQD%L6bDq0bKNYoQ#sW~
z(j-_%+>}2Mp`Y688>qI%&s&82y1>>D{P>5URX^-=UH3b|qV3LGLJxkG+U`9{;nx+!
zZxV^0@y3tsL~j=+Gj`6|N3^6`<8H&WcqnWq3i}9tuM*(mYu?X`Wq=AtZzFm1ZXT@y
zobJ~dXVF3#P8FIPh5TN{%U&FYj2RVFl3tC|*f%R2mKQBS^f9qgSN@Ep`qXFKMS+rc
zp)2f7?KOhQJ3#99OVKTaC8u|Rod-sL=|dhMHG2^TDN|CwTEst+OgR1{MuX@*JV_*8
zc7m7lNh4cTqm-#H({X`bi)peAx^krR+8Tx^ZoFQ^R{G|qir*n%`jMO{XB_l(cgKPr
zPj@y}-0wR0(ML$73$4TEL-1<m>a&2{sZ@as?hcjxn>I;L#+kG1l8opkT<}?Equb1K
zosHjQ4(%x3CW=3%=u-k2JbD?m*nBv{_?$3)A`F2H9=%)`k7O917sgM8A&|kNtHFq_
z;XxPrGot8JXXACbhu1+)F&cB}O>bf@=Y(N-;pbol+IfUGO2;IhP*H4c!}XDCysaj(
zvu!{1w)&%c&-CU(WT-~d-n!d07IZb2EPyJF_80KXY0JS9cc5)6MYxyTb>Z<M;$;ri
z6ck!RNb5>I41AWR6UVo7Lgq*9uzjlA8l8^V-3QU}VK+t~Q?<n)j5jK)na_I9@t$!=
zHomH>8H)vLT7*)4YbWFIak0ufwyj@(5U5jWKM7Tm`yuaJ;tosAZqFLgV*}9u!Eo{b
zXzQw{NM^biDf87w3vmacoRaH~<P(!m)^1v7ZU@m_&fGpg)|>%-1r@&8ncMDkTa(>o
zPb1wWmY*wBE5BJTKS9aw+L`j}PG|W&jdV=(DWB9KcgA(L%TG}9yKbiZy3<*HTS^yJ
zH`<<#DUC>)kMgjFeY=_vTiMD}0vUWt7IE?%lxs?cH17hssHJfX#vW6o=C)^1M>uv&
z_j4Uaxwe&G7g88&&=9?nGPr}YGE1y&Jm`AbukqD#tEDa)CDT?g?WUi>b0XcytrtHI
zc56KPc6gk|PRuYK6<$*h#-mRtU_5H!MD!JynCx51cvOINJlfR*TDL?R*A3DdekB?j
zm)c7fVZ1FyCV03iG{NW?`NrqE<s-k&^t_O5w^KO^I^*aufYusBnLb6ku7%_m+yX+s
z`k9B21zV&pf=%{kDSC1@xV7UM(Kmte%YEtHTe+paCt;8-vc1&zYXS1hY`;+vD2gx@
z3PGX4tz~wsq8V7fr!fZ4s2by5MnUE1C#^cv$x-{o4m)X(I#44`LeZ6y?!@>X(iI|k
zhg%{iZAZQT7G_)ZzAxgKrk%`C@4{>9LA^78w|cj5BDxFulXt4#1<2No>c4kb^*<=&
zNW~vD^bG7;9ybON0+RiS>fj<2yJ47a-SdU;slRki5JVfv1Z3T98eI=^^nd_GyK5=B
zL4aQfzz&OFT3C!8u`sj^gVBv(xVKjc_a;3aGlY`+)xK8)Nq&ijL{9)_A)oyjvkJ3{
zv%*=W=pMuDo%FZOSfwyFDNwj<+_%Fc^}h-zUA7lA;BOhgUI6?(1K10Ie`ElA0r1ZZ
zU@rjvl>zJp0K)~Bi@hMD%*Nwq!Uq0{=$s8KI~yn{Ht;o+ax)v>oz86Fe@VBTe6Psm
zr^&ouI41cvlIo{<#SbG&wk&^-?_;ZN9$#Q-{@lr9zvEF*czo?lJa(ru9-lH@LHB)n
z=n*n;`8gho$0U!yn=$z)FU3;)7y(RXa(t1c`Aa8{1CB>Q;qi4d@z|Ztcznuq1>N!O
zt;^+?@|ZlHvG@cpG~T#JBTvb(<kd+tn>5aBoWL+(kz1$IEr<6baIL*WkMh#o1iRKp
z{e>^LmrNjo+g>v3E28IOUF}N52QBpiKYECl>!)ac8^VQt^sv5OY+u%uFy7$49?Pp^
zZ~~uY4ZM&Q<BkS=!mF*tw#Reo5a!U1vXS`Tpj{4{EHyb!|HZfVM3tumGI;cQ#BKLG
z4Ad6%rdK;eN;tVQl)~sq(95ZN?EbuaOsu5yz$3h6m%1_8`F{JZCfl92Y&=}v{Ivv)
zd_&vcb;^I?yRgm5UDA!mJ|%X2uNJ>jYn{3bgXkY{IktnVDt>3Y-Agl3{VQ=DopZ}d
z;|G@@{rcyT0WL+;%_WrOO880!=*@JFPmuwhw?Xx8zk&bg4G5}5B<oB&?0pYuTK0Yo
z(woLK&S39_*VF@h?<=66w{RlbB*A}_q!y9+oecVuPUsKQ)e!c)1kk`TGF!vuH;M}U
zy1wj^h+=#*L>mlzHT(3V0SX`S)8tlv>fhBLpii{rUU1lEaXo6^+GZhGN^NK0tOVys
zlxy4hbx}?+#=*cfH3W5YO~r2}Ylhl=pfHyh;^r1VDk_!+9LB#zuIBP75ue`Cpmtc$
z*j;xv!;_V2c8}eomlbP;vSELf%B7@f?z;dUUA4ro3uYTW81+L!494;jh4E{7rZfZp
zO5xe1doGFDfP(hMdo)PK4&oH6;n&L`W-|z;qhb6zI8W&~aX1P(6b=1;(B0I@PZkON
z_i6z6tBjLN;DNL6b*m@?F{v6>h0p`3xC*Vh2vxVnmz!%$nM@?kTt8HD_ES*o=gl+O
z&+c?)Kc7armsozT_^r7{uggzR@_XY<`E{qW{GLX-t1LgsFIT=km!F{I_okWh>rQ9+
zZ7E&TPyRrKG??Y#O<G`Mr^YP%*jClB4|=9gd>C8l8-0+?T}g<8hc%%>v=DfC<6`+y
zw&!)zLS1~Lw`fNmy>8LpA2yH(XnwB0{(h#E7zKNu=M7T@w)X!H0Js-W);VO%473KB
zbOwrg8>h?avxyr$Y1v>yFMZM9Q6w6EF$q9M9fcLfe>Byc%X>C^Um_L!6W}l|fXPiM
zgNFHM!&IvHFT5^y6ym?~J|6nfQgHn=(~~XBUYlF*2(L_F;I%^1Ts_Tk^&}|uw0@>~
z>P~0%^fc1pHX%P1Dwkiy<tHfly?Lhmy3<*HPmyjBHf}ZLyT<a9nDD_$DZ=<~h-IM0
z)}z1k!XBj((6nFV?mO<FN|%k&d*g<^1>>$yT<ItOAW1{iWCWyI=JHDIjpX@?cHLud
zMjO(COuqbVy^j~|2G!y}A=K)GNY~N-43VhS|NKq;4`b39`XAvn^`QS5RzUw_;Y75Y
zLQS5s9sQ30S^r~D>wh+bzM>QN?AG1Vt*fM?70{GPo2RTagtr%5pSH>NAex{0U|+xQ
z;9ZLxI(Or`JE4W@w%57~pwrZL=W}&J<DT}F&u*VOk~W7zw5zh`>S3B1okn9sTpaFS
zsc_TCHnhL&het9Vt}`AOhT4wc0?D|7x-R_Cp3%Ql2_s!Zm|(SQCL11PAr~>+L3$Pf
zSrtpKJ+*!gW9_|?{E`ae4Bf-<72>%oi?!}T<EwfP8cNBX3`*H&WK4NjiUbg&^^8|I
zlsH!d70hnuoeZK={{oNAE@oh<5Ae9(OZWCA-nuu0tV!#o*Lw!zW2S{O-d!gT;@v&j
zh%>l+g-LA>Ml)VA3yy};v!47C`EbMdaGUii73K!$e|coRfot<h>DE3)yhY7L*c|j!
zu*b&{Q!-ohSe53~rixX;1?r;ha7#nt$N)z|fIE$+PoR3E?Z_rQu&$k7DGuAb+@Vhu
zzQW;91`J_CGBLHWAI_R1neI>W1od=lUn3*#r^xJgIs&$SwU@UB-S%z!9rwNsmENj5
zRZ||RE{xXGcw6l@(+VBe{WqNI*B`kZLgSuiQcz~xm1Gm}{-BVsCLFRE(bm$^UrYIq
zq(c`{_BmP8L)bobQK}0b`#iMI+V>8Cp8i}nr*`tR&vMaLMv(?1%J~Flt9+f!(E5AF
zJ-y!~TKDvRgD}0PSFi4#-mMTJ<LUahfHd^r{X2U9wtN4c-oLANiDw?z^fA32!ys=d
z`8cZOkd=COXYV6~s~=N|<~1yrx(Lm1lc--8)eiM!aSo8<rLMB2=d8q5U4^vcZ2pzs
z7uJ>2JR>~C;n<bVlH?Myq$M0Hl}mYvtV`~Dvg`Y@uJ6nFw%;)H>z2`1`EGn&L`SV$
zqt&#4x&)-Ii0lqov!w=TUjl2A$Xx=fDnX9E_CQ&EanEa76Rr}1hAM#{7MA?&y4U<X
zxcmN`jYz>QHrgJ<mZ-AxSE*ODCDJBiWH;m7ALHxh#sV393+JqwnLDZxNVN;j`}9^?
zMx!8g)>zoonsyTCE=`*s1Y?*l#dFoTg5glVe9F&zW3sOl{-$}07$u|&oL!r|vvvqA
z?V~t}5D!)*u%FKK>pz0y`VV>7TC|jy^`P|9Y8Ess`Ui^sCw14c=}wzMWIqQs_APf=
zZ(7K2*D%h}FS+i1q{mQQ<34w{=}l_y+o1V6LoBK|Se27sZ&9bAFUf3?-FR&G7&}X3
z+fwcVe?y;Laa=Ms?H*)2vW&SgEhaM=QCxAAWNXVSXed#suICKxr?csl9G=<thS(|@
zb7Nb%&_poJOu&scI_?q4VWbwn3^mcP>+HjZL<~KXH2sIp3oce+cjDb0PvrE^!e~&_
zrmV`ckdF1IB*&2cgdlpB`g+Or0?PUtm31kUw6{iBoyXupONoKFjUkNlnB;!G$qa6?
zNM`@jXn#^fmm11L=f}1cdlBrVN8JQ(u?9;&;~SRlCWwv@OJ>`}6ArjavR%rP(7JgN
z44(MKpQp)_G7(SPckv{+c-mKsRUh`7TZwRGm`je-BsnNuo)XC5(c94yW;MoZCfe?h
z`y!<1EVhx%-525XYER0=XsMD!RxZEsa}W@@@K_}jHV3`S?v(KE<OH`nirWj+_q{_3
zs-6%dQ;4qtgu0r(UPy>{s*+Swy7xJ{LJS>xjXD@REd98ewBviFAM5n7llzD+LI&e3
z1R5`W;$<r;7B*^PgY#zP=$&F?#C~h?<up#5J(Xk`u^Mm`8cN6w$DQeQweoTis7n+2
zq2dd)Lk5aAK+}FKa;UiaXB382=TCu3tNb#8?4YOaBYGG39Z+>5(Yw2$>Pn(px}oY&
zqFaG7H5q`HjF3b>Vi&Y!5EH=G2q30OX#si;L!nu`4)n4oj$?G?>=?kKoh#6eu&YOg
z?X|H|P>S9oMv8V%>zYNIormbibFuQAqdZG2dY9q~uiR4<a}bXG;6`Fxi{81bUZo2?
zv^3v)%-g!?&QtiDntyV2_I_H=Rxj*4XCY-8f@HK>s=qir(|LOaT?@21OuV%QP7;=r
z5gt<l89aI~MM`bvf#lB^y^@R)D?2iuFs$oIE4{bXO4R}v0CYE8ybl5Z77Bm~DM#-Y
zMfF>#|5N?ORr=FY(#~MnrV^e4N6~3l%fw_&)6M^OfF`Dwd6OG`kN0uVT+^0u7WG_{
zg<#n=+4Sz>BS?cIg}#6oolmE3@E~l%Gl-Y)<TAE+DWMIC8cMJIx!V%j9sUsm)mlHJ
zW&~7=w*$P~%6B4knfO<d?Ey(%%Lu#g3lj|KmAB7qT=%c_NjZ_<a`2KJc*KmP%YJp+
zAo>8=El=x4V*pg6%Lm^2y|7f4qJ`D_APMudNUQPDE`)EE?BJ*U!#n9tlQ2FJTgjyc
z+Gl}J`6L&dOu$c<=)a@<Li|%QD8zU3j3*RhzM|uxOKo(~4eVmL^cH=7eFi5V0~hu?
zC}G+FI(~gdhYL<4F4<91V47gQB*qawn+g~0=KKp{0*4Sx;8_UcXNw8>tHc9IHsb+f
zAKI_S*e~F)X5n~Hx-IeW9Pv;U57^0>c#teH#_o6E?DQedrq4rq8V=l`U`4-f`AHqi
zVZ1$&ErqtZ3bFQ=&Q)4tlBlI81>2WTRkg3rEMEUOqc=bYx3HM8aLke8nvF39LDGc#
z#yIcfS67rm#VIs6?g5<1*vXfI>dRZ8&(ZXgakh)SMzQv8`yk_&8+IB!8t0<FE_K*)
z^jq7}pEA{JGoR+%rWM$w&?&Klb6258JE;iL<AUwq(z;ddHtBTxWkk*BW~cm**X?2n
zwcilur(5rCt+FuZWbsqG&n+SGqQ8{zTt}aonC@Thx}z0*eoiIry9;)2wc)pSiVjgv
zHWyDB8=XF-3zAY$esnJ`zXdmJDZkCr&)0op9eFs47yC9*86R+$saXEiv|IQg`|(!6
zxOE1*@{;VvV@e={M<2p)L?6~erp^(ZRGsB6%dt8O;we)H<W;o!iOMg;%UYGIkzH;l
zksH5jM?y>HCd1Ck+8tJ~t(`RW%WZDV`u{}p8KRl>B5b)`&37T*Lr~RsV0%88dsUJ(
zz+}gT5gHz4xV}{)*Bb1XLowKUf|TsVBi@@w`_f0JL;F*wOwQQ1whys|cwc+&XV1s5
zgm&~f*`IHEq5}xHT1=6l&I6<ecJKqV#)tbr4_j7A4hAS5Esdp|iO1`x9e6wh<m6Bu
zI&6^R@iu<;3P2%#mOYQK=aKe2il<}lXx`#ucp#>hoZcZGjs++lL?bjxGx4BbJ%xwk
zKuV715ud=LEvJjK+?6B0TEUY;4-w+xm#8waNmN~NPQItZ6Xuz_I!V_*5{#Z<7n_$$
zBf)(4+7QKXjEa{%v)^E4vh{4<+uX1#%Ed}v#Ga(soV>1+O24IB0bT(zt5{oO)a|!9
z)&Cp@KMaAb4ZORRAc#+fVt;L`QhW+8WuF~Lr}9E@8bS0N9?R2y=-!Usl#$Hc9^rW&
zKf77xlREJ2-hPJ8mQSs<11vdR)ahH#AoRodOc6hehxGnQbw2WsX-=j;-~Fi5c8v3J
zz-+I;OnhURy)Fj7v4g#y4T(l%ujlA>M|*v)UaNYw^`!PqKkd#7f7-SnRIm2yO9{s~
z;i~MaF7WG$j6Q;mQ8~4LTkVBD)ykDKHlqzCclU1f*JibU!|o-jFgJ>RA}_eM+_v%-
z?(XEaq0J$)oNU8@BkdRp;`5xa>XL@}?d^pwQ!-JH(%v9sVp4CqJj1mY01}!aBr$~&
zmqN)3#&i$E`&9w_NwIEg=?Uw*S5ctIdgQ=<**LOJ(f!tOWS#3W6J=n}Gfgh6o%w;u
z(xjc1#Uvel6nXlQsjB@ra`Z6+Tr1r*6Bd2k0Mh)xe%LtrKLe=Qx}PkLJ^=u}RX=0!
z{BG4x{5&LORq=dYq-<*mXRHdRza?+s(roNzti|V(0L4?yA|1DbPxBZWd%=!Pkf-dj
zbmA8BO!j7$DSIP?ZXbeR$g;gJM6;89G%aoUEIKlIT$x~*8Q5icFp;bz`=)s)zB>=W
z$Rqdjl;pAB%z41G`mZTM8>7@OptSLYdb|wDx?iyv@^fJQj`ipYJL6i8eyWcfdT9LS
zeY}Wtc6u}04uXo6*KvEdM3|!??HS$F6VsoENK$!5pH%H>e8GIlW9C{(V!)E)B}y#?
zY%OMlb-}LJumyPgKtq^|Na(M_#--rpelgv~7hzq{+(pxO%Y;k{v#zInimbRIw9ACo
zsu&mBQ9YM~5aBq;=A^6PohfQ1VM_zr*2#4AX%HJPAV#!b*hO3L4%)w=8f^-n>enIA
zX7*Z14pQBB(pLLy-xtVPfG?vm4N*{52Y1wcSQosV6+Zz;)<L{Z43LNPY!%`Al~*00
z>flPku&yUL-O;uLP;UTCnmnS<ND%oZ@?t@)VpF;*1M|d6GDXY`WoT2T44;*_UIL=Z
za1~*`Dg>A1i~i2U3cc~|j!UMJo6R}zrFQAU_>F1}LE{I}J?qwQ6Styp7!Z3oTrZU0
z*YDpxjrr?VQr~p`&u=5-o3$z=H;E3S&*f!99&TQsacFC($uHSaC~PRt4JuQhd8)@K
zx01XZnCjtb!p@u|oNIvQyct;)9PZa&K@0{|@ncpxSHGgmz`2rKM~vvcl5lgn*DIYo
zFcI^`cGb50Hr(MuWDwuTv-v6>HdMcf7w5MT$l!Uujq;{1t!N{L<^3AM&GUY(sI)ya
zj9sqoLc(?M1=w;oqTVhBO|E-DpYEhv58N`N%vAh3NcYd}NxcwP&{XUP3^#=F>xpq~
zpkQ<6MNdiR4PcuShLkreWhVIJaIU@)K%jl!Wu2u-eJ}^W8$DYkc{3o%{VjxD#fmqg
zux<9XM#-q+w}O~=l4M!2HuN^4T3N4i_rPLR-wxP}vAZorM}5+=71ahkI@C(?PJmk5
z*gzPJ#_uA~B1SFx5)b>Gx%5`eyV0K3p|)w{;wEz&dPjrwbX)Que6QoegV7afnxD1O
zun>|<(?^>0>H|wt3P;{0iVd;s*Wb;P(d{h+$*p1tW0uw}t}Ty#zmmKMcz=7ITP|hS
z+MpC)0X;brX6*EA<GrA2Ire>`_kPj)s_10`G@a3Sf#Cyf@o(^flDtYGHxemr{ewJ%
z_(MuBA-+U$u6@eSg?+0e9|o@a{0JdScONC_s#faoV?Z4TcZh?|x#ZXKOr6b*Lm&t7
z|A|oj6H2J5e`cRgC11LoO7cl!l<%hq$@kMj?=VDRT~UC3(lXj%U1)%E^If?648UAt
z@8s^zF77@HvJ(ks;gryEC!2L1ywTHDlFtDbZ=WZGw=WQM^QI^m`B#oNp>^?A7cBZZ
zEWqaNyyw`Y8b2h%HiL2a1_|V#DM#NF_p<Bi*XYl?ZG$rjbQ0Yr!Dy#eLFsoOJ^#AX
z$1O`hU**!6J-{VYkdu5nl+pc?)ot$5<z`J|G%fi|!@PN>rvx&1#LO(c-FeGAtAo)s
z2kCxdGa3{iNK0@j%Hmfq?vywFw!?u(-;y}c`=a+E%0sW+RUXmKUD=Y+PDx)3i9lo0
z^7yW9gYP|*!HoiS#h9TF%=L5V*=}EJ?cxHP7Jb{eP=B<gdJ!MGxnT=sOstF;KnjIr
zlkOc#c^Ed#P@XoOAo>nD<G}!#Uq}nT%a>g?V^_@Bt=if<_&u?=h7E<u?<ijMedAWV
zuAWhc#Osn}oAH_oLF+<6{3UeJufAWXyS7j@R6nWprTlacYnq?tGJBC9V-=fgwr_h2
z>?Qzn6K`OUExi+q+4Q`_Rqdzy-sUkka&sFi*SAy)(@&#Zm$ljJ(uK=&<r1&dgz?&`
zcPj9^TTOfh&c(zQIM4hF+j)!jY5Nsa2b+)el#kEex=dfvkzZgxSdk9@9-=baULE{v
zU#3zD@mF|O-Pq_vXnziQCtn37`*nw^4btsNTUZwiP|n*HD>v)5ZJ2pK`CzTS2A*3X
zxKmVGz0Mj&2ww*h{Xj*xvEC8n%P^~wd;_@h{iafM<ttcMzEop5-r9{4zRi1nl%V15
z4^_i@xl1n{Ug{rpL!6O1ieD!Pe@vWPGMgu?R(EObbs@Ym_NqibA&w5}JLDV2-{l#E
z`T5XF@EDm@lJ60v(`nx)^rN3DRT%g25if>wdgp20-T3|oyy+xTN6B-(_4tP%M0e+z
z(scYTL3h`(B6-Rd>`%y0rjq=K7|HX;gq>8wx?p5<bz8%!w4VTUMQ6TcKYNy+d`io%
zZ{r8i&+@Er2f<HC9u&3gl#aI?FJBTbKLaRU?jaN}`8lm%owVWQ=Kzy?c|`Z*vq5q1
z16YhV@^rRO<z=K)N$v-vJRTtI&O@-x@^}znE{}UU6REsgy4%+s7mNO(IoSHmlf5M;
zChq<HdA<Y)>KEjTpdKQyw&(WPF?_2ezXYZ-JWSY0H>?W=PdVbq=@Ed*qddCvK~j$a
zF2;}Zbh_d4VHC*kAplf9zas3;N3hNEc@p4^`D6`bl9Q0&)PEz2_22T0f2YUqdDs|4
za{$JF+&>OPV{f6;G=xe+_#;8`Cp}I>nfZAfBk^Ydw)ZJ_SR%Do2Sbm+V<q_uI4a9u
z300Q7y%G%2N81$={|yj=`#VAM4<7M9c~r0JOzFq>Vb+p<?0hUIX4`_b`t5+cn_~=K
zTKk*7LoU<r$QBoEIWbuVnQ}NKJVR!G^EmI=l_?7+q8~wia;xR+Zx$fi-)zvy8KJk%
z2z{~>%C6@HWQ|9(b%wIB!ev~~!kzSug>2Xh9#D3gn<sRaEW%!hSeXIr<qEg?(31Jd
zzYt$TDN`Te>3)3`U%}+|J8*oG-k}!Dw4nn9^NTa2uE=kKFDHy&Nyt(FOA1<5_!XiE
z7M?NA5BEK)exzl6&rg4t>=;P;SC)O`bOEK)^-E6?#dL+S9#ZufLsybX+(FtqGu#jX
zcg4f>o3rXNKY{IC){dD(t|MlO?q|}n-wfY_T_tXTJZxWzdYMSD!{vB5-Z<)h1Z`4`
zj$VHby}13V*}d8A4!3vR?qK_-oti<04LCU8X2?3MO|St*S?f^8(UR$<NN)MY<>^(D
z7|C=fYP*2BKhK>4?{mjKHjehXUv}G!uk>PvcXn>8k-g~Ik8-iEW#M^j5adrgcMpDr
zyT3sao&6JU`8vQp@6Xtj;e5e6XNlYUvYg+hj~+)T)%7x^mmraJfD%}#qbG<fsI~*E
z?ds`5YwvjQgHclm@uD#n!t|KX*my99Ro@k5<AfN!QTv3LU<K|@527c@#3`h0^D&or
z1$D$=*e0JDUE=AQ&OYA4ld`c_L3=yBMda^m3wOGy@C{IJIasET&*1n){!Je7CLYU!
zWKXcnnH?mDwqM!en?cW%nPFzZefHb6Uon^&^h!*kbB7<E-fyiYmNq!r=WcviOSYHH
zBp)8cua^y|_oMIG&*EUe-1+%$Q5Me6UyizIgd&{m{QMPC!G|=wZk?Z3bng88Zz)Hs
zb&}6-`1b4np}e_#0{xDu$9$)f@JqmEqk9NtY1;$(ur64ev^k)CKsrKHjxfXRK^W&G
z|7sa=W{8QU>;KiSFte#79F4O)I7qlz9)gYR)Ia$$Y2jzhJ5L`_0-E&lh&C#lqx^U!
zf^NH4$in8=ZEiI}ydT`8PpKYIsx`BjJ`bTA@dY$VcbE8q@T9-aqDsGY^H$mnq6bMH
zM8Dt()rUm2EULfcEqYjwM|dFR`tDiv+DlfwO?<H6b9#rmSv5O|2l%?2QESierhtuu
z<gdEc+>p7R>bjoRwGw1?ePvf&myBGOtQ;`<n`(U@Kd=>uQCkEKTHhn-x2_X<1`J1!
ziu)__yFAQW!sTuV`4&mc=9!o6#hXKJC4KCFNovR|eV6IuN_l#2*c?P*D?8}B+zhLg
zn-Ii`bpejO9A{Z<!DY}VWMts>M-;6v_FZ(OEnf3Xhd%IM&@H~ji6oQN+ac5&lX08V
zx9?q>X^~V@>70rN1s1M%fKq>HoMRfyFv4|KzJlY>GRfrigyc1ula~o0h!&IH)lo}m
zhN=nGuapM!UeKa-`u1zRwaQ`eD`u$rHd%?t@nguXq>Chic4a6*t}-mPg=>-0@x77N
zLI1yGwLG7T(e0Qq>auPX&!iJA*Ov)kd%Z~}zft*BCev|;(dkMw)Z1kdp1L;Oz$A!o
z#{6fxuoLB@nRMwwipiBlZvc0^Sk%w96@7NyX>h>R>64wgr46%S%Hb?qo0YU|rnM=C
zn@>u%xLCULZd*yTZAZk=AC$)XaevKI%kHg(PJLdYuTu58Zcdz>EVrWL=V_p<u%XYC
ztc$J~p%t?S(p_fwTjbwZO$5g@-hh$UwS%?B9>UD*<rRK?HioY*ActCI1M3V03h^Lz
z)Ac2+iFi0=WGfq~trQ+t+zXL8iwKk~E%n&G8?j`BI;xf(OyuKmU35H)d|H>>H)VIx
z8oI3PlKTk>sl7GJkA5$u%Gkf!-I_nm7{skXtQw>Mv!Us<ZKS$;_B~5lnfV3rv{aHg
zpjoHb-lY}h8~wi#WupQTz2aN~`;{c#IW~_d=r7GXr@m;7M5;-Hy=2VMGaqh4jUfc2
zp4s(1`w-%Xkvy+T<tc=$?|Erg-@`pUik|$qDsV>%AFWbJPHF3!Z(UEatH99KUX7y&
z^(WzdzBR~HUwdcki)-{4nv6v*3~Y=tK0p1Myhqt_+P%CmejSCVj?#IWAEr$%CoAWN
zaUK`>lFuOT*=hS|Cs6(yTlurfj10$D1o1qw$$p|@A4<{MMG)AAz-$8nLjyJt1kqYh
zqCZFtnw{m#iNx)q&T67_e!3^M)taCF1%9SKkPT8h=BL7I>cRYUF9pm`Eu4t<goVl7
zBj%?9xcTX}`W;Wrz9_r)RbhL*yHXjP25RPs9HF%R8^`c@jq=vq8v^G2-w&GRX_^wq
z;O71B-{_S@)16D2<@JqvV~o3dniA)3+#Hk=c3U9m+-MBQDg9kh>0Ht7O0fFqLb6X?
zOQg}(p9qrq@D%--x3TnYkE1#&q_Zw)PepH!tgapHo!mOW5&2~8is`6Ow<E;0i=v&W
z6pt#_#cg@1yLKgtx$&;`TZhle(+|4XvNBJ?7fwyH(fSeVl*;6#MeZ1<bHK=CKb&}U
zi<lNII#wvc?%$qB#d2gT$!5Q`*s@NNeeQm-eW=!!-d#-zr$0QS-U+X%2YR=!0`$(p
ziRe&ro&1XQPJqlWV$h8<LjN`+bjgl0Q8=^{sxicI$neLKp&LifLG9R>xK9{!u|j!l
z_w=`H&Lp8T6Jy(j_6rSTi`dck9-6nqSg6YgInBcZyB?@Zc6#}2=;JoFI--)ZI*PXj
z^Kv4U+h7<k)+e^FC#$eiThgDQ!i0U9u+@JRtsVX}&EtGH&9uq#ILY$J$e!|4WVeBA
zrmJe(c%6;!*LBlGXz-oUJo%|;E)mVnk@-?UZjjlsUR`>$A64Jdqi>MAei~wi`vZj6
z)B`=*Ujce#;Y2hcJz88v3k1mY$e<_92z^B-bkdyyRa3o#m{g=}?Nv5*Gg4iz@wOBO
zi_I=Vch;eX+;%~3x@~ql;+C~<o8?xHGFwxZ5p-NPoBADmZ}AeZOmdH_8H5{i+kw@G
zZ0$Jko%3`D7=R6<e-0PAJAmD9gwtDcTQ=3li?hvAM?2du_*AswXme6-zhIk3(Ln>B
zs;u#jkm)QbdP55nKU*z!{BXCfJeCc~%1^318!CJ1<hWJc-w#{zS8e>V{bhIRxu2de
zU$f@CID|URgmYg*S!cqz`=Okk3D+xU!b>B`PQ2+jE%GflcHzPMO1-bryQ~~{Hk3KT
z;(K3(_SR|-MybDa5KG-&k$-RE-&y>74gXd%kkEN>%b_lUF#NX`!`$W~SX|@L*o_Ap
zErnX!i5Pvy>{==}c2^A3f4x6L@AD07w7l_|X@V5{`3P?O4nJD$5{PM+U_q8(ZpzF^
zd1J|s_5k5tMo_8)v47ibUWveCe5ZV}bKT~5+ZOoJR(Z?e=*b89fO^t@Rnb$v_hK+y
zozD0Cg^nKjD|)sahu_=EF19hL<j#hxYFM<-#3cc6;g}P|T8d_MI-d-2b5=Mvz6Jzp
zsDWcmj{m(BwCermUG=^<v8wld2-AAktE=~Yc~f2QN7&e(2k!^y{h4}Ky&uR+SG_BF
zuHJWtG1dKx`IptZ<xm&F?s^yD#z8!&L19suD!C=_ErrvHgM~8R;HDM&c3N?WV*I)S
zM`%GtXjz)TuN!uz6*wKsuHFyhZ431-mbOsu;;kIcpP}AGc?<O}dfoMIh0N8vs>bTw
zB8+L(yD{HU@2n!I-r1;V_5LhE>iq}>RySja{@vjG|JnDf@r&%neO>x<B)Ld`jv`F;
zN3TwQj^<4|a|~hQSRT9|r*~EZoc^4^3%VKD{b8;hDS3K-gj$lAubqev7+JqAGK~{?
z)K*c=dTC7XKwpGlw=krb%EV#VDxW2C-zNF-FWF5EN}ScKT~RMUchwlhT-B)58dLao
zjtlpw<o|4dl(2CUA@b+cA!U^J<9zy9H5M6gJ2}0AX`CIock}9H6cM*+C3zb&J|$JW
zA6-B)CYf*7G_X!mn*%_{{apC%ZqJb4Je2O$rVUqs?|v9tAcNZvV@H2Mg4JJi&XCka
zv}a(xn|bkTUC$(=v5p_HwyBlooN3?Q^~0JresgC!Y<vja9CCh)9sLzPxL#qs#E^;O
z0KdKyr46D>;69x*Nguw4OddcczFk4Uua2$$B#`7C2!pG%`K7c9zudmQp|rj6DTrE&
zL+@;f>N%RX_#@Tc_&ek_*tgA`Gsd>#Y_ss)&&|zCznTYWc=9%|#=-Afc*fYAJf4X3
zEk0vx_YUCl?90TpF#VdI!p2A2LCPvuNwc3_+xGxYT939$omHZ?D4;}z=u)YO$_?Y*
zgVKc!sV*owG$elFU0m+xHxJ9I`~|Hl7s%jN<xV%O;?baYb%=!tJb9?E-k%WvdM0Bw
zX^!l&bKq1U3gQFFjg>pF`B6S1R}Gik4Llq_-qbU=v9x?-aHGT{dg|LeMmn=sdqq0S
z9`rswm1>c`{s9UYvgvY%cvyh4D|{S3I@@!!Nbu)RZ`Fypr$3Et$cc7*$L7Hlcx=$O
z&|P0KuX%`I1HOf>eT_i<<0CgzNIj*Bo-EhAOGYA&=$5BMVe-QEw^FxiNOK<5#Y2)$
zeHW?CKk)(uBgr`g*p(It0Y48=f;4THY#2WW>bd(qG%c*Jgu;g2_yCXsyXvFAlwI|K
z9SOX5k=HNDYj_}eH`T={`-YPAS;E%I+V;^Od9}GQB5jm?4$s~8A<p`Yzp<lSXsp|%
z3S)caAs3@QWe0FqdvHM9egwC7e2^QeZu$SHI}`AluJz%swf8zFCn1w5LxmGTqLK)L
z7(x<}n5U$u`6M|cl}QG~n4qdkiMfW*s#3IEv{h48HKkfZtBTT6q*~)uEk*g>_g(7@
zaohjB-}isM=ebUs<^1-$=HXpyziaJ%u-`O+99K2LN*8oU2q<Lw<!}Fxsn}s{gBboD
zD%)D>I4Db{``xZkv-bOx{ZQk_c0eoBNU3CJL4T9cf%}whvNek7-+m!eAiccQP`FRQ
z3-Ue%UJ=5Me13B;{DbdFVVOxq`32Uj@V?gkoWi_RYrg$kU#lg}nip!$%1_P7%gjg#
zHTSdT<!9t%M@NQ7;D4d!j)j>8g?ZNKY-?dbo+UHX+`BL(Gb6Q|wJ14flr=j#rBy3S
zi_{h^o3?HqX^n_#9rUk>6=oM?WLa&gCs_+{{=&@Rr*~{T{(tmw!9zrMxZeFanD#6z
zg=NB{v&ryU`i}5Z5jpT*K5zoO0zC&_&EErlfG`tY=bgcF$zMmfnhib*KwijF;olti
zmXC2V{u%FR$<EFxFsG*H<m6k;Db|9qR%^C73ksK!n`t$t=49s=<Q1kC<mBa>$7U3y
zo2{b@Et%#_YxYQh2@#XbIoaldqFk#vctX=j!Qtj4Yo;}|z+8}CDX`f(E*EMiqad>=
zRK|lIp3Be39@){6L`Wk{a74z)!aPd>)V4XxT9BTT1|iZRQ!>h|+?;G{c7Zt~-<)S1
znE?%$XH5&I;`l#>?Q8kuzB^|AXZQ>00qvL%|5@N?U94b=MZ%WM22P-M%K}*e6_z)_
z$`1<*Yj1{%H-{uyt>%pEY-=7=b*eR&s&7P2o;l50V9ChL4~Lsd7zs~Z|6e%zMaVhK
zKalr<iBKci@RvumU}b4gD;9g7E&`*I6>2JjYEAmdpx&PZZXtw91$jLD<-@l;8X;J_
zI6m;h!{edvj<gh5%}Is1xjA_S=8%NK?9_J2?Je19FyQkGa<a@eKlzOqoacG!>hoA?
zkM&sCKjE((>V_=P6IcUSvjtE)IaEJA;ok!I!O}vIqCAfXYkmyW7}g_xc(Y^}#cK3N
zObW(9iQ2@HpPw-@+mZqbq#(zfZ_OK%k!n*A7!35>f4v??U5p>4hkG`*Tv-1{w;L_w
zRR)jBvWPgSpA68lX`qQMP=CGPFB6W#$3gwzl}ysWX>{FIXAL_+C8Da%gY{G)RBI0W
zi)uLosul;g9PY4~VmvOcFe5V!v?7e-=W^4aXQGC*WP{GlECOW>-!n6<X@F3@pe`+D
zP^K{4K?_hwYhE~C%wx07*1SB3A}2MqFb}jPsM8E+8cP98exN9_M`9~k3ZZv{*2O4`
z%$C%Gj4?P8q>feUI2cq8sd#8tX!yTUHyPQWbTA&s4$chVO-`=noDoDLKpVlli5eR$
z)&Kqd0P;v5)en5zOsIkki#yh)Co~|ov2E^svLSI?p}xWSdL%V2&ePcR_~Eg!pq-V*
zam;1d7^!(yto#g^d@azn`B-^W`OqG)>d1yR%r4B#l+zxY^Ay(O621eL`HcM&{vx_S
zJ>g7;V+hAdEYw&Y{A+=cRrJL0K&_7-{u)Q+lbe?_CL;~%!&X=3bW6V3k_i=<hC>9_
z4Tbq6Hp944-5NV*9xP<6`32$T_>44jQBEPOJhD<?<iH^M*EnhAlbw?tmY0)L&;(a4
znbt6SikTTBthkbElAmtL16c>kAY*->20bTKW>x=w^yv?$r+6OJ-k$Wy^S{in4C$%F
zufV@(cbEr#%^U}PxDeV3^&a-|Cs&skroL2(+2El7-W1_zVAOEf)CJJM{@^jH6TF}v
zTRj&p$=Ns_V#oOz*F8@Ll`0Zb#cB@4i7FcuE_zObSmomQud_890&w5BoI;q*offuo
zWQFq}>`%}I(oiFUmc^M2bgXRVf(#gtY2myZYE%0HYb^A&g7mzcvDr$eW@L}a8ATcu
z;`)~~NFzGd$~;o7zVqM)By$XOW=oz0mb|crqs26i`hST7#(dYOp<lrbAbnK7n%Vou
z)l=Ipx|yFajI{y*m?r2m0s2$3SZMj~G~Tf%^@66f+M87N0$kaRhF+0DdO>P{_D^2?
z>sFUbnOK@#ak94ckuH#a1l~pEz&#Uco}$0$&G{rRfIgazuZm+lF}471fGqh1(4LMS
zlLhNT>@QB*1LkeGjg)I3x+}6cw`Vx-jy(<)Q3lS+&P|O|r|c-Wtde(3w5Gy)PSrbL
zu~nFD83XevuC&5=%N{u(D@X@Dhxu}j4kqN(beKkHI>x1$iUy~1#^6c*|NeRSiS<~+
z_>W&+*mcJx>_pAsF9gaEj!pg7ogg1(5nNt5cK{4Z`s43{JgHUC-o$(Kgz4FF%L-F-
zrKZBw8FYdXq-1E?z&dvdU>*S)#x}ykd0|g%E44Oq@|N!$g`D~w3BipvEdxnAfx>~#
zV^7N7A#Cezm<>VS*;Pw^n+eS(VbK|T`Dti($RmA}9;tFl{|s4&>v2h-6*A#b;lI1@
zbDn~5O<s9@W?xB6qm=|yzFay7=R?(HjtHx?^p&c(z&Z{r580rhM_6!KmY<$em<ek!
z>lkQJXbs!4ISp=s%o${)fF(g%*jO6i5HN>^V0X1(NJ`BC!%1o;+%Mr$Zpc&E9y7Lo
zbO+l5_9IxGB+!vLFppbd*3O5OFW!mc-6Ptk)T(V_7yFvlF~zF+4{8m1YBsFOphMdh
zRryX+v0N6XnMdTojd(#iD8R}!DJ%V77Jz9P`MF@-QdT0yW<3q_=M(*YRg5c6SnMkN
zJ&W^|oR8$}=%{x&+2K8gT%TbOzCs6`1(r<cYosPD=48uAGtCLORFT>RDsxOmeg@vN
ztLlY2Hwu$Mi<{JR>bmwtFD`x58X9WWoQ$n8(h7H;bpME}s8m=n;gn+mg8*nio8ivs
zP6wjMwdRF&PEPJ^iwjK%DOSvuJ#upj+>e@*;992D)_cfOXp1of?rkmR{ERG^3G*P+
z)@)dY=Y%&hKS!Dt74TSV3XR*5>Q2^@Io48SF96(z<yygSc4`LX*k1g2+tnhp(ZT{P
zFT5k(K!f!WQtVQx@Aa1VA$edzruzz;FjOfAd!%+X1Ns5g3=I6EPvN+Kb;WWx0Yzt-
znMY;2CH1*KxovGDhqJ>7gbNxRqH=i+_h*g{0o@1;5o2=Tj*LdPeW4v{wu0>$bga#9
zr5*)ZRV})xi>jnT!KiIb9R>3!^a*8xs-)5j@jlMnCBLuTj2zM^6k8T<7%3vv>b=OA
zYRQB?C+*R=ptCL6aj~W3j$TxR+8kDwPhq>ldyHWFm-g*hZCo8Efu^zDi~WlYx=*aM
z6G5d#<7Pl8nE%Pxmk&G$?9xL*?J635G(#WqCK<6gV6U;DGxF0ja`8eWtxTSZb;%R!
z(P^{Rtb90k{xev2xE}R|wx{(d+Egpw&EoBE259h1aL1D-ci5n7O9hTMy_LP;1R4qP
zN|P(7a;3;XU6L_yj3pCBO<Ez^A3)P(!2N1w#(1*Bh4Z#J7Au9p!6$>@CR8SM_ned$
zaOVbMw1<~-=HjQJA3xC^!7Y#6+ZEil4{aVmy;XxUfJp-HA5)<{@HQ}yY;(9;LDK=c
zsq`unFmT`mJ5GrU;I_|ZqQF+bKOEmYv|~nIY9UTJj>*kFkrd&^3sk2ytql&0aGne^
zL<*V2Q*FVVJli(jU|9)UZAD=;^WrU`n&a}r%^lOhunSF-npv0zvlPwRkPZ0Mc^cXW
z@<<=Gj{oA^g%6S81UcUSS2lp7NvE<65F5ZsEr(_!wU%sz-P*~d_b&@S>o{v_A)0L{
zWd^4J|NHNAA&>M?^@RP{y6X_zI-56z^RM*j2X23;&rn;p{A<e@-WBD82G4{$U%6lN
zZ~Ju$#0)kOtJ)R9J+wT#T?A`>9O$km*Y&VB&-n1z|IsccTLN{H#Xfb~6%uY5%Ne%|
zZeVt@o7bH8FaQ4xAihkam8)$!x96#n85!4xu*U6=yU?~32$sb$JYmg%7cwnbDQTAc
zP|~MeI@(5WN4T}bJICPEV8@L(t|DMfqry1d<-j&0ZfTowtqWFcr?ro?68>wvmXW9$
zXo(3)&>F^8Ad8u{Fx#6`ENBK-`o(FFA-^ysAD67KsC6n1#udKmY0xWA=>4Xjc0IOk
z;kd3iP*C@qp$zr$OoX&7;z+>lw+vF`oyew$GqF4m5&m}`apSoF&NEuTV>+3ba2|-p
zj^8$^Foo{mK_`QeAQraKppwJYItWfupqUVE9r9q8!rY6d*zitxh9W<t5s&$Q2%Kmw
z=xoVP@0gPYyMb6t*7Ip-C&(jxlwSLAy#XF_g=f9sdQUXK$-PoJ51{`4JDbjbxR)Q@
zF$cCrVRZ^tGy86SY+fGT^`Vs^5pPv9Qenf??yZa6uA>$W@EE{<|9tU8y~dt>nfCW}
zxE|LXI_!AR-~Y?H^z3dKUj(NhY!$iYX{eVc^uqI(d%jVzEOi|AIo!ji{rgzZ0v6hL
zLakui#l^cG+_nAdQz8v*-ePIlh@Nd)11H82@E=Bodu2SRd&bCgI8lYJIX2Cbi(5OS
zrt$0!=zq9F;sbCMW4l4c>khkEN)DW{!a2es!-8d!LSqNUn_k;?QNB40y}@lOshhNn
z5hK7>LBH$xUw_WxiT?X;5<E%;A3E=2>%aZ!W+)vh8r3lF3ZwnY^1toZ{<2?(nv;9L
zAt^XsVX=2{%mTaf6!!DXoj00Q(Y{N?JvRK{y+Jd)oy6S_yyHw`{lK-dv0$Ucvp;w?
zAq)QS^p9h2m4fyFk9ZtS8X2Fg{5jx<&*Ip7owlkRotL)V!Omkrs|nRE7#OW%!_Bdk
zFUUTN#&cMJWP^zp4nEL?YBN^ayLqNHALdv%(w0Gb-I7;?A#CRp!+Bz-adc|So*u3r
z?bgk#3^<j93sAH%=fLgR2n(EY#Jk`^un$5;^Wo4}W(KUhUV94Lef`X-)4qBkd3hqX
z9DFjN3~{z5``_vR!O{eTlk!ODE=6$kw1|xSY4!p6|DFJxv}W8B$Dh*#!~NxjzZscN
z<GH)m{nOWAyKrci7@S>jrv&e><ozt}WI4{(;qHkv1ofhd&Ss92k9hiyA_{k&H|)Kf
zj^Ck85^hz<91m+89G-X!eC8?a*RPtRSL3{m&wt`48Orb<PQmDX_+M9G<p#ip_)mJU
zO<~$r066y#ghc-TP2v36Uf7Vf#cI42j-y-P_K*%<%Y_7-{l$d@?&-ptJf6Ds>inv;
z;fWhHE^HO-n31q)Y|AU$!Tsyzv?(NtDAGP7;bID`nSVDVa0(zxXHK>>5aF8eX<ILC
zxc?{V18>NC@4v2{|D<dG{d$*sV>QbC6`Vd{$qMgz{O_+PT17&KQ1_dO%^NL^-L&x7
zy>mAkY}ww&f?ef#`1=|D=D{DHfl2<~_CKt}5wu*A#(SJH@k0wRRP=cuwtxbc8{{@y
z|C7rwG;rcPo?LlWu=Vo)d_4SBe((@ns4Xfy7Ly0LkvWm)V5Erzw<zRUIy`Q{JK><p
z$bv^gvcOU#kM}yQ`u@XF#ykGc(WK>o5e0`UF2(TteF3IwyDgW;p2B%+jKp@s^lv9V
z=TR=xcLc?AG`6fej;xbj{oAsFstA4x^+Zz^ya^hT)x>_@3s(Pl#xAYW=}PRD|4Uur
zg}ZraPAfS~lEH&?|NZ&`@<<=0FS?IR$H$jhBe<T9xB9lzf%xPI-i6{5SaKOG2T$ew
z3g>#nVUKnFA6l;b>#2Qbb8L1IY=dWytY<U4$Q-ixr?5UBS4}3H>`f>`crqAK@zyey
zZZC1RM^#hA<nwKRbxw~b^~gypgj0@at&h#mw`QflQwlJ4Y4g)@<_*l?S>#b2Jjuw0
zQv+}iD-8}{rNYB!(te`if)`@{_xH;u=CM{ObHDiJAJvS*TCC|drTnw!a1O)y3qPmf
z4}Ka9=P}1|>;Gv~+th!Oy2VFZz>{HnL0s52_-SUlp|lxbVqqZ2;{hpPV#h%t2ZQ4P
zQV$3gk299@Gl~B`ntT{77P3p&M%jxHQA>>d$-_@_)<W~X^8=2!HHKZR0RBFOpu8JR
zJ?ik8S#9GuKi5JhDs2<bznnHwNBgP2!BJZ$8wNZ^lb4YK+l+LI6A$g;f(Z=@IFreP
zpkRcCbyGNRU-^ix-B9uOaa0Z;1_!z9=eC?|A8;fco`l5F;AD#lhoABL@9*D`NBSte
zd;LPwy2zK|ufFU|f4!=;^$YaO+hgPY`}K%4E5YrPV@+YZH^yk5e;V|G0doo;RbS>4
zNi&wr`|RyU=U!>%@vwKFxzXWiSb^|<OR(0+557VN&(!!oc^<YCSpW;v==Ob5Y<s+^
z0fcXeYf0zlm~e(GfN`Bix~3ltOtdZH5ovhB&Dp5<cd=sbYRMLUGVXUlBp=7H<c%!E
z6{j-eIjoEL<XTZU55b042UqYAwd2gZ!z(>0#cL(ohNgUk3XVI%IkRxNvXwia@DQCk
zM@Hv&|2l0Lb$Cpep1(4~(_5Ik{BUlzM{iqD!opKM+hyxx3!aAlr9<80NA<5Oi(Y;_
zu`D`%SjRyx;N@KS!+lSDZiAlO$)(keG!x_fj%?AtR?65FaGwu9;i#eiI<TA`@X>bp
zU?m0_4nf-deURReiyX3*<w38M&y3;BhxtMq!X60Dhhk^3w=g`B4x8loP`}**t&ZX2
z6O3j!?HAoX+d9@f08a&iey5v}zY2}29#nofAM}3{|2T+#TzHTFIP&NJ?<4R1pXD3Q
z(RYpGOe*54P*G#>B?rwTnm26?059Xh2HWuyV?prp$of~{{or8w4@!brFMA~Io8Kzr
zY+oo`doGD>d4n^2wMS6mb6w)$-+jOf`vAvf=A;1Q2Zn)H|GMv2aYaRSzd>_W3mON$
z7Q-LjTfvJg7`#h@8Q?D+uEDz^=t;4L@b4vHclfIZe<kpT_CU02qJ3~6{0slX+tEP@
z!5`jyPlXHc9vOO<AH11DmD0#OYnW;nnVH;3a#P67CU-iyi^yF?Zta@9rjfNIHy&I!
zHlt=XTv<>P<2g`s8+`w*=6P@vd?I~}>=hrpzJ}Z_;Ciqk-&9{C8|jDAd44E;hrYY{
z<9Bax-B@e?Y=}7-TqFC`A5*MV2c<RYqML6<_h>zgVMYkA>B0OPp&JD*q!^0Q-<zZB
zAB8FIZH?E1JJ;xJWY2WLP`TvBbVWbUcSY%IJ@EUtJ$LjpvPJzS^fR(|`=QUz$h}0a
z-XE{jA-7xqw*8H4bbk!>5?xtM?uX=_AoqHItPRfr7%E{v!vRKCI3Q)f1NJhU7&fw{
zbY%y)ZtNs|cYXe6@Kf)3jI#~69xU_u<mZiS+Vd%Jef9Gg!(qB^9GL3s!RmtR#)=0P
z3^cNawK3G<LFm3Y2vcl47~PeFu|7`>#`=5&F4W`@EN^3Q-B{8Pyk1Q1GH{J-`;Z!)
z-Pj@e{@hRu``%Ez{tbLLvf9J&$}7V#)EaQ19f#xfiR5my;P*ypnA^T-v1vxOEDf)8
zx8jwN<j%5AwnEvhn1>!CFo%0bpr7B#?K2WXWsSsC=8i-^yE5>~h8M6l4!nR@+%nPs
z%b6H<OCEl|mKW*c#(eTIS53h+vY!h~HIn$=LagUQh1gQBk3pYr7DxJQW6etNdXs6U
z8ZaQ#NWgJl0wcB-s{<olY5^}8O?8+F2>-m`LCgLmL*3v7tBUzR8os3$=sgN2SPk|%
z@L6^pTqE-%nG3%TKA|^~%!k*3t1b-Q)dS%g^Pb!QREM7A$%Rqs3aQ~r!;4KPnF-GC
z6vJzRw(w8EryHHQ^kP2{Re?Qx%-Nqr?yN0^6B_#Tgx|K;AwC(W7i{HY&O$U?1$n_4
z9t_tO$N>L#VI`14vNlsQuxfB;f%LXkPSlh9A5qkw=z9%wU4sp#Sbo!tx`EY%n^%nU
zSsiQ1AC^>@UK|i(bz$2TWzPep0ga{opCTZ4pd#`)mwW~(dP~Pz3Sx^Xy$^M)!610s
z561GPejU<l2){9jyGSmgTyuxtnB7ac4iK1nIQ~u+_-v}EoMb(TBJj5(KxTz-1{Q&D
zX9b!fmI(uE#=axkC9qy1*?H;{=LPnOmh1|p{tL)f1N}linL)~~Q5mWmLP1wY!PDGW
z_D&!}x=l1l(eFfgiXK22yx24#6Zrg-QkZAhVyMa5FagE$V&z0_nGwqB#V!IFU{z}(
z*?kCC6WZCGV|vdR8yjI)jd_tQ4yY!OA5j)jESx96I2RGcu>hiNMDcJ&3}q*XI<b0`
z-d!Wsd;**k!9M8fg47M3GDM$^Tq0eN8d2)8E?C+g^vgJ2YykMY1%&T5fZC;Sy;yIe
zGNL~0If~^y@|nb*C)sB}f)8TZL_d(v!PJMn*j=LGG?#fXUw9k50s7obilqfmP3T+r
z4gfFqoC#ZH1U;qg#YUKBn+!06;`wdp*Cy<{FR<kl?vUwckY%#fR6Y+^q-?f^e6~`w
zj%YB^X!Z{IoaKsf=Cf@S%SKo1bp`ALq64lt9tzkFs+S)@#-PXV<{)Ihfy^CfAIXev
zo^Fgy1j3w!02zSx6SZ^0Q9Oy2Q=Caeli3#}8%R`4Pt16+@osA&+*I}r$vz>P4yyrd
zv0sR0fWE*M)2pm?OJlRyRr1*Y$iU{X>qOm&=CNNX+(e@J><^NaDSAkBh-e|bzr>4O
ztx}_^0miAThABi=MIEw~!H<Ce4JBI6YLTq8>bk0FY$f~@Ec*PoD)!ygtS-?>qBmK6
ztpsG(sy?cE3x4~%vGzLDT`hO)S#Ps&^4Z9JnOMQ!W)Vbf-Jf$`!8g!a$%{<}GQe*<
zw<6i=?l@96vv!o1_kavQ?MZfwXbX#_6s`f`Z_joi8TUY+@6q$+UaTR}4%Ulg$wWI@
zKcX=}EBGEZh*FqEvd@^6%COF(4y1mFjiMAj^njl%1kIC6bXZXy(HTXPDbC9f?iToz
zbQ355-s(4xe7bvLO&no(2j#_lfNlXTB$=6H$Ji30=8BeT*z4K?xx;S|yhhZ6=xZRX
z-67=jB+4Mpd{5LbC)o<3nLxLI%7_+|><WWlfd!wNh<;`tlk70jRaQ=P4&pq)ud;(g
zcYtcLYwR$Qi`R9q&fR3kD3)L#1G~w-B3W-Q^!ZQrEm0Q8Zo$cT_$fa~Z<-g5_s0x=
zd=03Kh;#TwB%u97I@fh9(QzQgs&aVwKFBVTtSX0hp99??s?HnesCPZQQSa8|p+wIR
z)#C7?TkzS)8%MYgkJ51*C3xeQ_TlhWSde9T<H+&h(J;Y!u~*>jbGMj3k0aRvAOow-
zJ5ji8-s_0EP|m*c#$FJ>lXUFm=YR}A@G?)JOWvqM0{Bph^FC1^yrUlH;+`~DHRf~4
zXO(IgE|h;wJ{wn~8IONQ)Pbl8KS$J`d^YEoiPC{i@D}_A#W|K_E%`r5_6o^b^1CEk
zMY2}>KFPLM!=4<)!v&VMoP4(7%>?G`8}iwfw*>nvltED&l0B@3^FuW6Ag~5Kt0T4N
zvE<W7Q6kAgh+=qel0_?ej%X0jEf&Y&2mBy~43c%^Ln+*NqE0-GXpW+EqHiemP8@#h
z0KzS<j_uc#7YPP=`4D^t0!<>>*Ge{7=pc)PqYMVtolhe=P1KXWNOXg!4}ZzYXEJ}8
z=!YQ~t{;EJNj8AbA+iib*+4#*NX9aVmlBO3*-*ZK=ue_yd=b$r!!g`&zJ#cZXarwL
z^qB=^>3kKHXiFMW0pCEfB_oi=@GV3#g|U3A6OH5BiDY_3{Cy&s-gv%)=p2})U_RnI
zon)`@Pl)os3SwZh`KLs(&gSsXh@KgRvRC;bqM=0d_!mSk63ypFh?Ws8;>U?(>Pz|8
zL>=LF+rVDq-w??Zmho?$XgNPkw3>Xb<lj+Eyhl{V&ylQc7RIugUnH7O^aigWl4W?4
zUm-dGx5);!mj6QZE74p08qroT_ZZlEev3%v<!yeONS1FC|CLC#?YsOpC!bsRJ)$e4
zF_wSu`$V!;w(^IR>x*DPFtF|Xky9-1b78<9DQoEiZX}Yaf5=TlGL~K3jY#HYH?Qg>
z+rvGGWa@jlCy{LT{oI>K_Lp*Ao#^GUn3vCZO(L1XaUMV<V>!X=63M)r<bh7IQ#^>M
zE1WSlz$&Bx(Ga5VcnFcK`E&ePq5~xRfrk<$!XAr(UEmQ!vK@Zp&4^_AF7ZerS%%BJ
zC6R3D3LZsd9*?p7#M=<bd|u(vM6wJ&^A1Gsk<VXvEYSs`>%1e8jO7OJL{xhM#(9$`
z62%hT;$4VF68)2RBYKJGHt#{SlIU07i|9|H-*{i5;E5RL?>w0(n&>X?NAx4nAAA5&
z)k)~{0Ut=zgy>H`nCLjsV?LDV0TI)N6E&ZV;kcGUWF^wHG@@6DbZrFDE+V0&6I~%P
zXfF`?Ou<-;S|(8fk&Bj1G?>Vw<r2yM;-=*}Q5CI_NcOX;+E^kvZr!yaC!ZeL1Sj&;
zCJ{vxW9rqkDNeHL+Ek*L5|q`@rc0kwkpi?iM0rFFwZ%lT7ldnNM6&lZ(N+^l%@Coz
zK_tu2RD079$eyj)oq4kpHD`d!Yt5?kowF0QcEE2G^zpe|>3UNZ>09|qAbaQ=#{-$}
zm%y8{=6;u1Ae-rz&AnN`P;?#f%h&>$zrUO2&3X>&66DPe4s)yT%?!iqfEzR1tv+Y-
z{O7_NX{G-HaJTp`(E{0*{wu(}2(Hl>QTv|OuQ;mq18}3sO#(NN8S7SvK=w@CUj%0n
z@V!s*q`D@9H%qs$2HxzHHLamHYcOI;Lq`n#4gHGm*G0F6xj*=H<n#abdmuXz<N~wq
z`JlOw6PNma@Eu*}cmi4X`k2FE^_zlpUxVT&+=~sC+OGsRTm#>GHrxg7fQFxdJEGx1
zaK|=02JXy;-@EiFKHBge)X!OP16jS0!=^wM8uG~#DLxlcA-vi9BUuATHw1I|LdbdW
zIkVvva2JN$HgR^a&Y$4ksAF{XX5KG+7lt)<J1mghp*X!8`M3tM;6~55au(C50k{*M
zU0NxX%4L)}AJw=A#P;v&GmuRV#rWrkrh#h=>);m1e8b}1FekH`I>*qb_~kH@fwRM5
zKe};tE)09f)i57dTWf}e|LE4QxFxyK<i>*=$TGs~RI&9*TQB|lKJT0&=D}DMYvcRo
z*fV!Wdb4V|!&+cpngH(axu3Pb{4c8F$ob|f-fZLO$~mtb=U>-JAp5nMu_|Y6nny#5
z0YfoehtEKEz4_3pf$VYfOmJ&PP6rpu70AjWv2VN``6pa?FA~R~<2qMYr1XnO?3t`Z
zm^=D(ap9~+i>2V!1=l$(O#NW1K(@KXVDP!E#c*&BfS;!9M2mFz{&S0Q;J)1Q9d~aw
zH~(N1_O8?5I&zCwQd@g7bH-F~y<d2}bs$S<g{jN2jN=+dH0JptxdU6__pDYQLYx6Z
zhqu9)(Opt_u$6Pn9BN5;!03*`o-9XGacdl90Yk&wIV*3y-b40tTd&wqd#6Xg;+^2y
zu0+-T2(Dac{gLt+$a=T=4!+CSENw2q_mSl0wD}pn7qxM5sm><1x#7{2mA1L<(UQFm
zS2%0cx{fDjNv(sy9nm_%Q;r(U^Xj&!*|veZadbJj2Z!B;c<!}n4SpQ8#93ln6KG)P
z_QIBO_G8P{=(gC(Gr{EyeoGQkbPu@$u5SpK!&pVz8&D_r+g63|HQODAvD~EHM{uQc
zyPe>swmS%+Cbh#pA24)Q(>}#Z+T8=)8!+^j=*nryej?M#2uJ;s7<~z17!Zx+wMJua
znb9B}Qd!<$G`O1^jQ0v;G3|H4_de|p!1wg_=)a^r>ZRH3(Z6^5Z$KK-{(CRyv^Z<u
z0mtv44mY4?Y@=Ry%Tdp1HsPStyx~f^Wn2vEgaqi@qhoe?OaGYvBXN+27)<3*4C;{6
zF^AxQ?8O)?HR?mqX))N!x?gvgkM72N1!3J{&x2bh_MZ@Q>7*w|*_e2&Lz%0R_?kYP
zEsDqZe~ribZ_+6it|WHCE7*2W^PTQ#O_^%~_TFEcW%~uPki-dooDEN$3pMO$Ys_us
zw49|-&s}5u16i-G*sDi$?e5=_?d|%GdsB9(>s*NcJh(WfJ_DVzaWuM)n2juP;DP`n
zJKY^LAxr3yz+tz6z8iad;sX0QgKE|>vWT8_su)@Lpg*gk|JTfw{Y#&T122OWU&dn#
z>s7CESSdYEF*oaVPcyQA3||B>zc>6HcO%<5d@fv(elB!BRNu$~Ef2tLYQcUxAcZt`
z3igfP!8Nk5Ug*DND!MV`_9Ay6xf!X)8^F$6D#pAj75#67D}n4r8fv-PRxD}HUZ)zu
z^<Lw^k4*Qqk&i=-?5&ZeFe4kG(#6!TI;HzodQ*@}|69_r-u9%oge%{q$AEj4uKbyf
zwHIjV0$02;@VYspC%7`^#Eky%ePd7bli05*xcNQMy_B>o!pJ`8{W-XpI`~f?)D*98
z0(V|7lL5*?rT$^mZn)B8kfU9sRJvK2%bH<JRc;X|dnT5hWl`C)u;yRugY~mEYj<;K
zg)FSe=<KDDMmD@Be*Z@w>^T#1cf*y_-O+y^xME~udmf~`U2g$<aied8E8EevFG|gQ
zG3S?(Vp^hW0aun3dr=?@FTgx>FTgx(E5LT?QHcFY_OZ9p3)&i4{UjHNp;r$quM8_o
zU3=`54n`I_7VEsjSWK()*rnie;MnPKT}qwn<Wka3_#wLiDgWAnkHNol3(EesdMx(3
zofPx;W3i0a$6~2(QHs)k?Xf;Fw${0n)E&OR+G8NN^85EmSf7`Ymcf;I<JN(DE*JCZ
z{QajStkt?j@5CC}qof<)jx4GgXJq4w(C6%)SK<5Yo{c-AI}P0C<FSmg9`5$SeloGw
zm3U0$I=JP%;-DrkB{k`U?r?B>_R6F0AA|cSNv84{w9%ua_ylkE*#x}OCwWH#xD)k6
zh;8CC;Le$d@mP|v&a;wd!Ii1W2cv8~VG&)Cy<&FHWY{Z~u6S-Q?i)Xcp+4vx-v!+_
z!2PKAH{^zO1s(F-KyXW@WPxkS91rfADUSA)t(@^3_5|s^mA<+=l$S=O>=m7gx4;z~
z@7S7gyz+ST=(nK<jKLCgefnW34ws;Nj@-*7TYLPwQ1vNP%v223hur6<{&lEW@>xQD
z68mB4W=}<TF<rryg?;{HbaVTmEBg=j95B7Yr`-MR8ci5y$IL|RL!whei%t7$GzZxQ
zMMr>icAco4ovqOp?%n=Sbg@PZGcuU|;WOR$W{r3tSXRNO+=MB>X#hzS4)${uVK^7o
zjA#ahb75_WrkRpzCW9<q%Gk1+7NE&aK3!R<^hx1d*$ScsChuCW!oKWxiW<~f0Q94x
zrnQy={h}zkRvG^ATs_R^G>XNInTTX8ZY)s|#^T0$D#BRYSU*KeAeJf^1$@d4pVry}
zlu0ry(H>Tny-ZZWQHJM0@KbI$SL*=tkO1v)qt-dFd>&IiQRc<o4MK5+E6S>|e-M>Z
z8&zWi>Z7cbW&8XLvJ;Bt`TPbuy`c?IChM~%^CT+uT{-C6IyF%Mt%$Ne!Fn&LoUicF
zxsRRp`gm~M4M(5l{BxgYcmRu}SY$2LVeN=yE!ANY6k#pZVN(@hE!APO6rJ!XgWcm0
zJmLcTPu+ZjcwKfN1gVtG^=%HcntYbBe+;@*ryg6c==h*pb%NM=MK^)!v%8Ai2j8vJ
zfK{V6AIS1GWKD=<J{!U*6HGzovmqO+2=m#HO;&{YY{+IPTJ2lLg4qg1dx^FZVV!m5
z!3=(b5<W9b?tXoFBX&%Yk6(YFJ46*6+piHj`YigC?bn#WPZz>RwqIj;_y@|~+wW&M
zx$p{Hu(eni%O;W~3PXXt#cU*7tcjA9b8NAucET2GL4^HmtltRUk}Y>ip%vR_ry|~p
zog=E?=rf8fkf}58p&bHSv#Ugl*=v3?IP7wVVzi6d`+h5VI~HcA^}Iccx6@W0!^YZa
zFOOqO?R1F8vtxET$rD*I6>2g2wAPQjD_d`;tGpY#Wv5?xcNQFusmr$Q$s&kk+rj}p
zMcB4I*%(FGwmsQoMJN5r;IQWxM6!)~u{^3o*+zX>A(3pOKI|3|j<H9)4;vJLsmoE7
z#M%?dHcDbqRQV{YttGL{W;UO}T0eG}sFXGEZ>~Mh9x96WZ?6qvq0~&JEZyIt4P|GD
zX0S2-x!Q2%){<fYnxdt!D=J*nu-Kq9cAz=RO4;^dT74^Phc8(Jx;d<7{Sj=tqR`=5
z{dDFhV}YEl)iPMJB-0=M8?_hMU`1ZftOd$Z6#UE<Z4?`;DEgWAfMzL5dS;iF$>u8>
z^~}dWYZXm<=Af3v-chuI2=fJf(A~H8HITh0Wt5jJwwI{F6=m7dBlyg!-Jd&XN^K9_
zL5pfvcaUL2Z9ga4S&5ETqRW-&P9<^=Xy_D6ct8t1$CejEctFQW)K`bC1^SeO%%Z~<
zfuhb3PQH!@M_lKC(UoXQC7M%-R_X=zSTX|M(F>huj}FFt`ji`TAU!a>+o`V(#&1Q1
z0bl4~s8&=Ga9#&vw4zr7?&)A+R<ta@OMt0Z(Ypa=0p?&kH4!CFlpv<s>AQdoG0jdl
z0`kR+c6ty{BxX2Kv3SWw?xN02@v@Cz#+&aT_Xc&!#4MZ4Jrd{@8yOPnye($i$bE2~
z&0>z7((9aqa}e@V?mnf?4ky`ipjX*Ndq2A^=CYct&~J&UL)}NBlm#p5PSlyGf)A}5
z594QuA}nnw%T$D=UBJdG!qP5eGwoC?7O^FgT(PuE*qcg*rCq|dDjAk`Dch$AOZyr-
zqI_a$m$9=-hNWH3epZB~UC!<*!qP5hhA1pig)5eJ1-mDS=A4ya{XtnNTUa;Bu!?0U
zdZ%u@;SJ{1Udj#ttzl^$B%QC@%kU<<MkMv%TkIy0)OByMG)keA^|IV|d5a~ea35Iv
zH(bXCD`F!G8oteH#9*9@SwpkMuz`)VQ;A_Cdr?s{^J>F8VCevl;Io-|GtfariRQhA
zcUg;ADN8gTHEd?_cDiWT#!MZhY@GSNVF!DYNX`g5*(M@6BkW{X72%AqligN?Gr~@G
zU(q~s8QaCY;$@s)nX4Fgu}*fXYuv+n*{OwbA4{`SSL1%RNzqmF5aTE8ydrbp5aR(>
zqmzuYEzqZ|lcGL>g~oE$%TBY5hggcDw7^xy!)z3hEYX*&fJm0;OSVlBmgq~iQxTTv
zOSWH8R$v*NGC8Ga7SRnN8RrppPswnde1x@1z<e$+VVp-;dqo)M5tg9nD8zD<4JMMY
z9A#-rhOr!FYZPHDN7)8N7|T(%Rgq`CGC0+8P*HuN?-jKrx}#_?5#|fE>A8A4jK`Q;
zB9gqf_!{g|Bx5N1nyn#{z4av9NF?)ll5HoFHF%Q!stEIWlHFH?`8>(A&KTzc(=|x_
zTl@;2azkX$L8G1AV}p(wPe~EXRXu{faiT#%-#O6>L4CQy=l>M0l260Rpa)K|V4SDz
z>Ae%QQL~d_PY`oC&3q}>Savs;Gb~P$>3Wd2%URZysKOP)on^^H@_y_rTPlg}$Ih~I
zitv8y9Q$2{<Cp^6d33=HU<!3yzGs1wOttDaaQT5Xa+3YPqMT&sSqzbEhx4p6k!*+a
z>?K9m4(Hjcim)Bdv&D)+>X)$#Y!eZt-ooVq`(BbMzkamKMOL9`R{clfqP>>3)&Ium
zpf4ex4#N6$(1rSmPO|$zm+Z0BYS7o^vYo<#D(uvy!4Q|9>@*bU3cF#?=Zh{svnpLt
zJi~OX!EBdbSanHIh8KY%oMcy7lwG#m<tiJjWPda`2d9$LoP1tqnRcHqx?E>3JIQXa
zQoC%u%MG?#$yztu>~fQ>x66J4GIgVzu_X;>irZ{9Q3+eqa6Zso@>#+>M<%%b%7%AG
zpNrXnhWB0Wuv{WJQ~t)@AUXi^CO7@Y-XxlCy3!E(4%<#7N8|4p1$@fgwP2&kLAd5~
zkZW)iCt0mvZzrl3?Bhfc!2wR><JZuMqJzINI^ygc+{8)N59qGU3XJKI!EH?UY~(&B
zxQpq&on8cbU?anl;QpqEHgaDVJks>oPVWJMd4xXYhVtM-IOe<CUiM=q!EX>%xMJCj
z{DC4YyOEoEV89AjEW43=DZ;WFd4M7;yOG12^T{Wc-N;)h!m=AVJf%u9EW42pSA=CZ
z@@z#|b{9TT634Qe_$x|=Wq0GRDZ;W>;p>!7EPGY{fs$d_J^81Ku<Ty^YvmKm?#(X}
z$?;x;Un7#^y#{aG6Z0u&nHs#AA{_5EIQ$|R$(o0h!Rfx<MA&=Im}+w0z9^ITYPEPf
zNn{W4<&(%~Df@KzeHULIL$U)5d!!#<sKVh&&Y#~=ge$q)ymyj}6IXHp99|R!pK|^n
zpjg!5mxxN(>mfzL%nu}^tc2|fDHee|<~gJaTIB`tnUY}DHD3hrYf6Tzy!yO;Kj{-!
zc@6krNgP*s4Y^l;DZ^D>Fdv`@S9!sFup(UL1@nc9aFrLr&l8of!y%rojd<wu7)uGe
z4D>7?P9#TMV}6XvP|E(9@nu+Jep*q~3)jLz`9izT2gWeIkEons*~9r`yDZ!_g8L1`
z6lR!uH#!Hu85u}aVoGVmO-=c;N><Qlrf9~aq>RmM6wjLR9!j<f!ZqWARJbif*;2-K
zG%AL0ixhnq5a}Ap_bK|k(c7X0e<;cH6@+WaYYdWkxlGhl5_{07ooh=zSdr(mZ;MvE
zjHrb9KN}BcAh#)5%V(oqqIkKY&LlgjXxOs}u2KAZBH4Fa^D9KM@3!W_gE4j4cU$vt
zMc8*+^OlOvJzK`w@a~HKAW9*Uakk-^N`~vDHhiNZod4SJt%@+tHhia|=8el(TYiiP
z+qREuTV5f_G^X)D*Jyr25$gG9{yULOFPhU2J43E9Jvh}l#8HN5o}dWRi{?EQO^5W_
z^E5@viN+JjINS5-N``T^=btFTGPLKPE5bP2^RE>B2(fhFSBPXR9r!IJ!&o}-CPN)L
z>%dzo!dN=+_KI4Dma!O~OoTNt)-{H|Ajz~m^i|h5o~LMC=o>)ei59cNq5FVdS9CeF
z!Zn`1PgKh8hI+Vl=H_9TdMWs<>DGmhBf=EAxb@)UhNDc`iTE#)NcZ&N_lT68h?|K@
z*r0(+0{ZalM5S!>sOe4n@@xx(k1Tr<A4eoxC5eBa2x}0YfKr5IPvYf@g2T$-dBL-a
z;)#}~V4RCtpTPIslKJpdq*Asr>`S-)e4(QE!p^uo&tuZ0PrSDn#ODx6Ju!qYveQp)
zL-<FMOb^0tx((x>De?;c4d@DywA2je7$dHX8-#Dv9E2-J2jM<~gK)3FPVT+JU8-2@
zu?z_JsFK2)STRn_Sx}WU-kqqz6@6NHnk0@sNAMLyr7SP}*(&M$nv$WtHG|I|fw9PY
z*in2Dk!+(;{1_41TOaXJyzNL^dhsla*CCR&ye!_)E^AgLi$5=kti3thq6lZ-9G*cW
z+ct+65XrX9;oB5p+vf0{im+{S_<lu`!pq=knNy0^5Zxe>apv-SN`_-4m$ypCTuV)q
z%iAl$ICFV|qTnWFY&0KCBx4!P)07Nj8O_%y!kmrf8x&zIqxn`vSrAJe@B9L$x0rp>
zq<xh<{>3PyQg*UQzba#SW~QVEO{`TW@WEM<OcB{tCh;2CNQ+rqL`jt?d<PlSN?G5C
zIaNwHJj?^1QdT8<lm9f{Oi}&pqs^!D?J9)@+3!TY$iG%89M9?7;w64oQJdVH7Bl(p
zD!m_axB9=#Pf!ZjdzMw1#T%26ZiZ=H=$b0Cd88zeZ3h}hCObK%U*&`IWL^p*_Ewq4
z-yxE{X93?qBzw;SzD4<5F?xE_1w0`i!^zrR$a@pXc3;TnD#F@b$QLWZ+Fi)Y6yYdd
z#J4M27=d(;XfeAVaiYp1zJ-i}i<w)~iYiNZlR}x#pr(ITS;6CoWa?$SJCRJijK87?
zQ!nH56=CXSe3_yaP0QFSzJ*A}vWo9eGVCF%_+3R9%PRgz5yrBL8^>T?7MLbLEUS5K
zMH`5kDLP2hS<zjhp+qvh)jVCvFum1$ogz$cHGfwTrnj2EujsXAW$bl+lt^l@*ZCbg
zc~*U$dyU1M$+mriACN@)`c3{B(G1h0X8u**<VO|NZr&K^6p?J{wfqZ;vlMneHu<mR
zKafo3`YnEiNY?dRJb0X}3C#6dJX{gx`Yqm4(Uj(8Y#r}TBy+uvPmyE_jf7{c_)ChS
zB3A>=Rn#Z)L!hPha7Ooa{60~IE7}q^a;=C;>xwprjoeKU-rsKI)fAy+VI!|igsB_d
zH}c6!hOunsGZbMgoB69w;WqQdGMwq7NI&<@e5;gkv`=i|`;<>i?;rdi5!z<fYX9ID
zl<eEcjoMcJGm)&_t#++{GqSF`o!rsqcJ4JEON9As@4lUf5>;^Y`97axmpw4<;G3Le
zAM#(M%oNe$9NWcjD~fNyO}qF5B6(M^n@3K-6l81e;q8cIYwqC_6k%)b;Zqf1YwqE*
z6s5N)V|)2NqH?l5?d7c}+HxJwKIYwt7PGPzN$wx>nUfr{13Z>wrL1M%$E^<Vc~WK)
zEho8u%9kqgZ+VV=%2(UNO$FJw$rK9<Yw7KBkZ+noM7!z-d6i-$S-S^$4Wd%ky5)TL
zgZz{v+V?$Vuld}TYupd<OC-a(-s=82?_R>-Q^8Son7a~{us->_qQ2lAiAq^+{{E;h
zIal<4{_&_IycKN_$of3WV~AvZ9_3RMVSOIuGZbNc9_6npTG$dSg8WTITZwimI!P2V
z-I23nJp4r@IgXC=+tZLrA)m>uk8>CDS<2qeFKqo4udC?Og88k#=27-=d)-g)i;_&Z
z&vlw#RfIcRr};x7+3Qa86EiS{5;ncnx9;EZ6)#Cz+3H94v;2~xvK9~Bf8f7TxKid?
z_<WlS{1AmJWkEnc@-yVKloc0#-0C8~G!tWyb#{qgBa(G?i8p>3WpaMM#G5I?I=jT%
zDB9ktj9uov6&)iQL4-Tf-Y%DUHc^SGVblZTWj>Y&$EJrz1z$}h`|cIKMEYdMMtHki
z<(M{FYS5ZyCqrV?Gae2a5Y@oty3MCyKvW|SXNvH+;UtUpxM?HzQBmDI{%NOiQQj^N
zDvs*oBwG!1+wSv|sKFk;+UX3?9Xs8L8tL(yovO7S>G3;fv#<=ZcJK1_L=_x!eV4yy
zr$!!k`6qUY@VLj1+bP=P4}M;fE9UwEzpe;#{ea(Bgt>meO|M{j6|R`;hrE^|%=MqV
zz9P)^Bi>9A=K3*@QG~f>T2Dn-^IYpEiDS)k%}OLSn6AB~WO?E9JcM?e+7IWd@U{kR
z8Od;TEcS5G*4Syehe_K)RBl?(x(RdBFweMxU)TB#4>#>0$z%#uw9MHktKcZBs_i3^
zBhK9(?#tHy@Nm$#t<RY731a+|yI*O2z{Ar{kDSR+tIg*i`(CAhv3P4Yol>Z#-6bkz
zZ?}2iQB8Y9R01W6hv!M6=3olglOKaDjR<q*>RD4;WT!JGA8iehY<FMnn4KDV_-Y}q
zVk{+WXPY`Mep+`T^cmsduMM_Sw8t~r0p;^h8!yiQ%`^|gRZy$c)rLrN#qtGeRz+C$
zKrL7K#L@<8=amfmQjm5<5%#4Z?Uo{J_aN;ak!*(`t!b&u=TB|o;W_I>q6&`fUSAt7
z$rbxx18u1y?1K%pV~Vg325YAIlxtV)gCSasBJ6{Wv~h~C4?e3cq0)i|8*?qJv9?N4
z*q9}4L$!5^`i$AsHcZ>DsBp}lw&B`libdW#HPPOY#6BGJS-U3MPej;8(Vh_+Y@$*P
zV!JohMia@A+Dw~BB=ul3ZI>dPJDO?x6`>w%rhTr+(6)><*Ul4FaE!CL_B)a6t&!Rz
zNv0NUo3KdDxRC18)V}Rvk4P<^2z_?+Y@xksr!JnYv_q0ixI${99an@aq&C`VMY!&1
zqg_yx(srO{8||JXh%?-^troEe)58?3p6#>@B3at@S^<$PZF_B-A}notZKonEZF_CM
zq6MwNj-s6+nqk8J(m^|~2=_ZWXjddbdRd+wv>J<TsgLoD)t1_6p=W1p4^f3H+KhW^
zpDRKeb#Lt}q7u`*w(oiN*1l6Rv{?7iE)vZ!Eor;UvyXO7$<Th?SG%Lat!=yCv#<82
zlA$#_Ni!^wHNUm(A<rbugQ&t4ZQIFOEhXFA_Lyg~R#(Z;(*2wktYlxb{nqn2Ekeog
z&byx$rDUhuUhwRv#VZ-wz58nu6`|dGfVN!{*}b3Ft|%GWy$5OLrI@n{SG0Q%)&@x8
zX!jnX%~mqBdk@zRC_=lpMSG}xqTM@1i+BxVk!vuk_5qO`#a68$Q7J1QGrj2u?UbT*
z?P__A)C!hixKj2}yZT-k+B~Ag?6Y=_y<X5lmP^@>?b>=}X~{&gU*~8?R4m_&xe%SB
z4JMiFS-Dyok?dKy+8RaJvvRc!im+$pYFicEZ3p%O?Vuu$Xr%9nFug8bqqX`gFfTJ$
zPPDg6p|+l=#DqIkh1w2DY;5!puR<+yrSw@G9nZ#S^N1>3vA2%VR!SoMIY!&6WY~Ad
zX*(6+UfnotzakuC<Fqdn;a=T1O_X5@6|T5fSENDKiEyuOyjGwH_v$8Sn-t+*-9+t@
zBHXK+q*YhB_89B!GTAm)8D5T_=4B`MmC*~mN^COs9Y9m<bTWFC*EBob2AZz<t-`!u
zogMLdQEN>kXNwtHcPWD!e8yv@wqD6Fy;)lFY7AH5is{YKW-G$<UeyjL!t~~94;5j0
z^R&p<AsEbK3);iU6>X-XbwrDZWX+dqZz|dT_CI-*YNv^0f0?gcB9i@Oz83Tb#wpjI
z^R;IcVSkygHB(gHz6{=I(OD7pmj&8TMHfg`K!i21R$HLWA(DI03$;Z=C8qEWYqf=1
z8IjzPUZic3L_5-pw6luPuDDqHnW%zxq!(+CiR5@#qE%gkxkh@=bBXp0k&JVx79ok^
zT&fLMgmJ#6#lMN+q`lxZ?WMIuWG`5*%_5Rxdbw6gB-2~2Z6R8~zA|6;TCTCTFdWKE
z-enrR1_eGc&ed9DNfhTBS`?9t^9?PWNLq>C(B37&SZaE&(T+$Wo8wyT6p_>@YqhEy
z94Wk|eJ+VoSg(CaBvV+gogk9AUa#FFTFi!Z2=HF7&EANyEM|orntE^0s%%0kWz#xz
z^4_FHz9VUVhr!;PwV2IFi`j|}`QBT#d5S&(+OFkpk+RMKbG+Zz&MG?AVTf^urmHwx
zj63G{p>~{PrR=4m>2W(X42A2@pF6~}-J1CyNEIB{k-N1aL<jiI4tv-hZJ44v9kM+4
zY8FM+Vp_QD)5Z~%u&|gjrv2JOMIC`Y(K5GUoCjQ!V*cTMKwCp3&yF0>QkBnjMa$z3
zXjc?{UbH5zT-!uGvCcm7KB!gSMmclEGl_?_XB6R?#KT&UB0Q6LSZgea<C(<6S{p@p
zCh@S=MG>A!JglWF!ZV47wU-p(nZ(1|TZ-^Z;$iKCB0Q7$g?7bG9f7KDr=0QdfWG>d
zn%Pbk{fO3C5uQmrrj4`HXrLW-ngZ0|JsAtMAJ9NMt<;Ze;}qeU#ILju?X*Wfp?#qU
z&m?}MxxX)C$$`9lt3@foGl{3Pvx@Lc;%RO82ht~=Nj#%nQ-o&{ztj5dkTN`zcvhQe
zrzYZi?UJ1m#1ES9hv@SHpB}SOJFmG?UP{^dqVl-&nwezSe&Mbcv?Y>ExSse?+bxMT
zjs4d1N3HfwjAaIkjtzIcsCANL!d1y7t%o99m0Z&LDZ-V`Wo@V;T<KiaMk~UVPK8#a
z2v<54+EhijV);p%rKoePR_!NkzM`SA-ayL~6~+buy(x*k659f3@Gi_Joac*;uJ*I`
zCeaMGJT{(P)s7J@X6Iw4R=cW2?na-B+3ncb)vjy4dnEC=Mb&O<ClpnS+fePFTEt!{
zs}{Gr+HGxxq6Yy-s@>7<*y)#QziWvfNuOwyzNht8gd_aER$?dj>JPM+6`_84sLfY|
z`sI<fLQ&ng;Ob2ON)c)eO|QRCrqDScp}No~+Gzy5=jEQAW>h!nEk2e$8^mp>?xqj0
zQ+f3&`f59!uU=KZqv+j$`_<j`$WLUrj&b#Bc<Kify&KT3hL>(QAY~Z=gKJdR+u3PS
zjhgxzML7XwHGK6`cKWD>zuxy#8EzQlB|tB*Q+f3|`gS{=uU=RGgQ%2^jXPh%tcR4#
zaP#7>)Ckl^+DWS!q)%7$X<Sgv271-cq|Z;|+Sd%$lkN0;%|`lqMJMAX)NHKpu+yTN
z;rc^6ZK)Zdha8l#T#Ea?W^=t*(XSA$g+9+ti)u#cCls-c-`8xTw>u=md3OA>W;=bU
zBEOElwc6`mpG%ov$5yps^mIiyKg8*y72*64uaCD=y&4I6nWBar>(xlqFWG58t<HMA
z!!ph=kag9ED{9+um9d-tjw0O6?V(?@Q%S8}dhah}xWl2VYW2}qD#BfpB>jXU-1i-z
z*Z5NUyd1i-)?j_2ozB!6u6I5nWr-c{)=JZtDeBX4h;fA8jQSFst)K8>!brXAe)L(&
zHcY%*CtdHV+P3c`pUxTjPl`rQ+T{O&-i_L!lzliUwDTx^HkB5h0hoNqFH_$|DabWg
zmVSUpuEDZ&{V1j&*I-$?n<89;W$D!v4eeOQvh@%}bBNk2+DMeF=qsWZh)^r;^32w!
z5y{=$9Q_q3GvWPTj=n$<-v8z3D-^AZ5Aw;?-&C|W{v6BIH!1o$o||&@_Y~nh<!F76
zqAT%5Vzgc^2~v+|dHN-ya^9y?51%~!p_IWH*#18GdhRh<yXl>V`4s5ajw8)rC7li$
z3-#aaG{R?$9`Kb-cE&VLk0L68SaN)d^c{+3b~<C4pvQepJ}LEy`g4-VCNNPSLR3OF
zfr<KbyU&iElk{sui&;j%7@sM6?-LlyVz#=|be|G^tD=pa=KD<3FA<f(>D*O5)Ace%
zdU4C{GxQURyo-Bve@T!0hVo+iqEif;skb94F`e$T&1a^bD`k++9X>DX2Z(SVVZYBS
z`Uyp~688Jd(Jv_qP59Dhu72B2-};p5UMFQfLlds}EY#~NYMt=A&k{Y%PR#c;y_=o9
zeOKrM6(uCp^<AZpv{Q)hYJG~GqI}=b=h&%}@0<E^JN5K^OW$Cpp}ueHA1Vq>80EW3
zKWL{y-_80dJI(Ojre9IiI$@#j2l`z*mHF<}UA~niYMrpzcdzcFsAs|+-~D=soyvU=
z=o9R8()TlcmZBk0qR;gub_(%5tZ%ndl<$}NennYOpGWn>cKX)mxc-fuuK1kLe^4|P
z>hoLux}BKsX}!uRna`;S-o9sbe?>zQI{E&fhuEp7?*+Y;ord~e(i0RdffD_sC)=sq
z_h)^jolg2*(>E!)5pdD>roPusSAB2kUnqJv;g0WZ{iK~9`TnN=py-nX7r(pu4Lf=J
z!5iaF%Upk(;P3ZPk5qIuA;|BMo@1vLewvuA=+A^0KZDp}r*3{G@rNQ)Vn07OQTvRH
z(>F22&qH(|lJ>!Bq8kxvqM3fx#0nz08&N~l`A&vwmH39AkH}OMleodpSL`F2Vd|2&
zQS%cAiAqd;6W0P=lQM{NtDnDUc~-_UDDgwT+M>6jF^T*A0>lPI(-RN*)fLASEliwK
z#Vp#Mli}8YtezM|BsFx9NF$OOI!LThgjSUxu|W}P=peCG(bmK=R$rVTTFlNS9`ma&
z4ic5J>BXD;8;GdyWqQ{Wzw>J-hAa9LC`9a5)V%X0zh{N`LHcal`I=v2k*uh1=i7c^
zVgUIpWuF&^_6QeWkxb^gi8xCnbKOKda~@-n^GXv@PZ8$2iFj5~M&~jXAz~CwAnK=R
zHc_UcH;JYy+D){SXfX@va?dY9+*1_OMfYze247(CS<L!(spa2XY*A$C($GIr@E@gY
zLYJ2QErcJDEJG_%pGcOWl}J^DHQ!3Spa{#*O5`bewM!X`5;GNTCMr{Om}ol@_Q6j6
zQQ|m}yt{5Ku1J|FuWMJ{Mnqi1oXs#z=-S`Eorsad@ElS*F<a5}uEYJ?ixY}o=^D>E
zh}xGZ9HfBMhG;Qc+%?C)gNUk-rCrsv$Ujy@T#@t^P)Cuh=-sZ-)jEkSKTFvMU0?A}
z6ekq@v+FAVF5(VRDbu^H^6w_XenFq5%-k*B&_fI%TFfH5&8gB;ELPO5+a~|sVuzxB
z-M0Go5vHp$g^X?=`u7#^(oc$I5rj(?nTmD+^%GwZEoR>U4G`Zbs_3@gf1o(0=pm#q
zNIX;&(0!BtV9`M3?7-Bm{zJqslwK(tF>R~=P|^Q7rAPbI!^AxzX*n4t*4;pvJd0xy
z8;GP`!y^7cgzXp4EaJmT^f8g_Jr?l=k?cJdQRODaDMx@sR8xe#$0Ga{#dj}bDPn6q
z^eIzF5j!Q(>An=PBgi3371ty&KB%sHs@Ufwvx<XC7BQ$Vw~AAZ9O10uyd;X#Do#J^
zkc|)*B(Xa~Hk(I?h2aiax>z9z!tD-B7ZaN}WEo<MB*@Fdzzi|nNj6H%Rx-@XD3KcB
z2scV(N`hU)cj}E2E1NoGSz^5;<~8h{dRd}+ltY#yo{<E3IaNPLG*R^F@bmR^MYN)`
z!+)wjT69zN>+qZP^Ta$wZk8o*9=k{qwPt}RQL;!&UH1Ypt_`Mlf&XmzxWO2)Pf_EP
z!$1cW?Hh8AjS(W6e7agwHfm!;RY`np3fQ4V4MoR@)+?V?QoUWqh%H3e(%XE-h@(U$
ztS~j6jTKiFO((je=mVm#_O_bn%EyY1l1wIRUwCI}H$|b={y@n@vhNm&9g6ToB)r|U
z1IAL$&>lHn+$EB|ZoGIbiESED*L}RGmS{^ao=p_~l4#$4qR8#$EE^|@1;R5N6Gc`}
zhisCVDT$pOo-ZbeLMPc|@tTtTI=rs?WU-#;0>3k|VOX(vs0eGmScqO2=LL>6Uo58g
zA#&}R{*AF%%$7toUo7x9G|(s3e6cv8d}7TPi?c+s=8MGxq7v3OBc7Fr?MWC;)<lWe
zEr}h;*cVnJ4)u4)ri$Z|*o+r?G?^+A203KYL{CXf8`Y!9H1XX~hitmID2YXk`XOSv
zz_$zHokqf_Gp3isjbRR-GsW+c;3<Q;?(oEn#UYy|d{bn&cShB9pCw*WR1UGs7WbWe
z&JpkcH+*KWo1=CI&Jl^Jj#yq5y(F;)nF+41icg$mbHx`*HXt*u*<5if%@J;%I3<Y{
zX4Z9|C$?D~viV}SB+?V}#flLQ*#hyVB+xH<^9AByx=q#<-edc{B-8!OzVIH~3PpZd
z{ef-~$)3DKBxhha`5urZVud2?$xFqLM6&&sirbRd@T|4XmkQ$xlpZU}+SL3t@r#qs
zWumT<oy_{U`7*I-lr3lRY`NGYiKS=16}en=&2-3Ch`y58sqDdlE5u4C*-Eii$y{<;
zw^%7mSu*v`Ih|URiN_=>WiRKv6S+#<kTTLluZu^@XL;`6z}LmTTt|9uh=Y~rm?YBW
zZ-}OO4xej8Ye}r{XqT32L>EP4M|-ziD?ZP6_*^HxlEl6mea5s-OfPWA){EJa*aMKQ
z7po^YWN(Z0l1LZ4EsjmK$-45lMTI0&OaYt&6gL!&F6a+*k4U!WMlpCAhLf$iQM{=L
zTXU26g-EvMCgC}qQh@VdiLEz@;+Jgc#j|(BOi3)YaDAJ1#FjY@*}GzgBzCLtk$6{l
zE_9apN`e{aTsx30cgQviA4%-jG3NH0MgAIxY>SvsiB?O3cBt#VMND&&Z56L5*{8#I
z2W}Owt#!n*O}s9Ny)gESX`AT%7RsdN+b*^!Ld~~b>`;W7Z@W0Sj(n2l+b)htBF(p5
ze5(jG-*$0Y`9#gPU0fiNns2-Cd)twh_rz*R)R*29fljjbMW~XYCVF3--QWnfLtK)?
z4CBt2c8Hvf4%vrdtRxl)vJXY8O%B;kktT`djvE}fQ|wk$475vhaPqlZ^is0b<JLCc
zEfSq%d&EX1+cIub%pP&;T}KLg#XU*v48*xtcx)ya`{%g1u^$N|Q7JPOEsNbJzLGK;
ze;*6qEz;+ZqKB~`i!)BLPsAk^%cP=w@rf|M??~@}2$95oF1izUKumR#m5bR*_Mj-L
zW4UPffg{{O5iW^&jGx!>pxEFf`&?{QvQ8lTTpUp}Y<yJ5FT{>rj#!R}eUjMB@n=j&
zM8Ix`?5JoUiLD0NQBmR~J0@l;+2<fTCU);}ggY({NMgT(?6~mV>yUjV%#xVvgfphE
z#55<_*Wwi=Yc^q0r?16#PO@*rMJ4MG;l2@fKXSx*Qm}nQY|@0eu_wh)Nz^LeiV;dS
zq=>nEE8cgKof73rwhh9a5_^eC*`5i@Vo!^2KW6ZeI^>M_K@zJz@nP&45x3tVJ1Zti
zVrdhrCY}|2on+_4KqZ?$v3}w?G3^saxbMYmN$ehk`(F4SaL9fTW=X8xB<Avic;88O
zUhGw}P9QrkiVr!$T@W)Rv7aU_kGmlLaFSgV{B!cjyeB`5y(qRyqFTBvb}Lzz$!AQL
zMdD#coE4&%BsO94;J^y;m6PlzaYo7BoZP3&Ponh~j&Q$-SV`<S$bJzIoMhL9{-w;z
zqsc#Zxh_&AQC@C|QA!pz<;O0!#9=4dui~DP<xWZI`m6ZbNp?qkr)2Y|#Irjh;+P{Z
zcSMvVwth;2>m8A#=rf?-#E7pQK7SY4l1Q`vE{-_K?uwI2Rx#zPZg)ki6OM5AL<dRi
z_7u_mp6En2PT70@5IrPOoPUTyvLQ*?eKAQA&4%|y<adrZ?~8VlSm$DwmiNU_Mg5Dt
zTRs%WoqRqLr<Dxnqemj`62@|Y_bRzs_p#Wa2xo-HVxJ<M5gv=xm&vE=OC^2zW3gTm
z%?OXh7DYHCJQlZ<Pn;1Ri$96vjPO|0uE1DI*sYRycs=%DBAGffY*B=%Gs6x=m^w2o
z{mGF!Gpv?GsWZcRMVLA>Tv0wTb!PaDNT$vVHLl3i)27BVZdgGiQ|E?TiZFF<xTgqH
z=Z3tW9jSA}cuABxH<T#C)VX1r@`<T)!#pCHIyaoNQ#{iQmnE^+rw$I(4A*|a6l6>5
zhC7nj_aM^^KVEgngyFU%)@It^Kw+4E-61m=W=o<O7JfX1ae8`PV{dnV^804GBHeB9
zU1JC6inIGUT{%v!{C=8zUZ5+^-+!m;#vYi8FS#M$YOD!;mp-M`@m*&vK`I#f<g5d^
zGW7)buE85A@y%e#bp7c6q3uoJqpHrZ@pJD?GLx_vke%!cVGUbY0s*pbBp?!8FqjOP
z0Y<VhGXbKgf#4FwsuimitifO{f~^bITChfgRTQ;UtXiRl25YIfW3?6Zd*1h)J98%!
zlz#vJm;CN?-}{{Ryyx7rpL5T>a|Or$;s8FjgycYMb$m~im~+MI|1Lfbwpqg{<p~QZ
z6fYQET+KYCkB;wB68|XkQvP9{-aNMi`7$#y&B>Z3q#c?5@_x^Ck1ufO<Z2ObuwTh^
zaad;NG`n7anXfKL$0Fh&<4e5ENO=;=GnqHbyEz5YI7bL|VW}d&lF4QLK)x7xB>9Ex
zTE$r7M;%{4B@63J*bLd=N!A4E8;tb3g?R&`@HODA%xq^(8HYAzWKO+Xs>8x=W+;_3
zB@?5I6DHmqf68m)E+qdI>+75j|9{yu=jjkw)<rbXB2qaNS?Ua=yO_fK3e3Ybe3_Q?
zWiBMFAZ7u(UJBHe>|jQgD<AXgfEIk+l<J^N`QG_3aU=V^jeSWAG96^er1E2wQdyQ{
z+Dg}eY))-MmO6KEOdjA+0*utr@g?4#=`Ta4a;W1=wzzZgYt{*6q~?Bh{UhTWjOMZ=
z+d#>`&8`xq-w(j(;%nw5^TQZ<5yduux)^R^(pa7cl;zMOikOk9By;mJX6hKtVVUb-
z?>xR|84}NcFT-^`hko7vGy5`bH?e(lsg`#q@9TVOjjX5tYu%J7De)6G<;7)J5#GV^
zIhQqq*P$uHm9_pp_9bP>n^QjRqNpfc><CFosk0lrjxY35=(1Fs<>$a##6h4{9A+JA
zwal6pK^CmyZFW5l)WsJpho<U$ZU<zzff{7N_pABdxeUu3q1vPis>{LkOZF53E0soD
zcLB>XR@+g_j1dBrC{2X&k}=24JSw2L8GW=l4W%r74MvC-F?ErSyIuqg6ZISiYP)31
zZxJnEtoV{P#Ua3J_<A<!yldiRn|79Y*}s%=Dt%f@eo5BFAL>Ycr9Obi8c3$z3N`cx
zQ$7Nt5gp&(<~Z}nBs3Q&bR$oTSo0E~mGeDJ<vYbqSLqp=GOO9LIaQ^OjHi@k9dBg&
z)L&awJ8&*u`jTzMrCbsMt%N3s(Z%%~u9=tmW=7gEw^X4mu+%5N7V%TINjeypLe|B@
z9B0ze#6EU?mGOO(Eb~a-uN-5@aHZz6KJqK^1k18ioMg-20<B^y5WhmZm^97tmlgty
zMa6+)OFawe$2SI0#$1LTKwZc@3cYvPs>l&kGKVh5AtW24$ABH9-i0#%U;LWmAahF9
z1s*fV^c>A`Bg9>^Ec06GOL-pi)EjC-juS3nCcx|BN-!3DPo8vSzZsA<#k<%wG#$)o
zVve&pEOY!rQz?}BCAa*tR+>?ksMV(UOTY47q)f99bBm{oK>aduifW}X<B;hl{ZdP-
z3)zp$_|quMBB;-`ip>ZYzgGvOZ~N2lFUy(B`D)tLcr5gO&xZ+=cH=IjuK;h16U^2^
zU1eU#RF(PlGfq#Ejh=-Vi}<CV*M-!P?Xa{j{gQo)p!By2SzjcYOM*E*=aL_T1!H6-
zEu2g9kEU3KhIM{+XvSgg{bkLPA(}^(l(YEt6H{rCGicdUo5#%O>g5AHi_WD;6EgkH
z{erY+o_qd{?~xeU<6H2X1r!tFgBh95ADYrc&NU?eou8NeCVtTgy`+v`%^+*CO`y<?
zT2H<VS&p2gj>OI;@@ual9kbl8oOl}HSVS~rP5i%{Et3624u!@oMon+yn9J5l_Ba$P
zV`eJrduWMD<Csrn&0>~IS(Z5>Q$xx!HKZ)tRhe#*3Cz)qS)1hLY);B@9xZK}Er;ei
zx%&GimIL{y<M%1(zNAj?vM~}4gr(z`EDT?UUk4Zqe#64xb^MY=uxwGYdl}Z<CRdWp
zuE8OiOCa^;Mu>7XMp~2O1SwNrZ|IoihdGp|OySa(?+ne?*;UOSIhD+<K^MDzY|{VM
zB+JqwL%)&hxRm9JM5x?*{W9M*M!vkRMShJKj$}sWzIg_5E;)Fd85L!WGo=M%-VqgL
z%sc*9Ufx%%DW0;X$kCCM%_~BZk+p{U!Qg&J^5d5TR&R3HvYfLM>S|Rd(1z$@G3!W1
zS}^z5l!J2pP~+Z2$8VibxH4y@s~oe@%89XZCGC)=(Hh8JPu9~=xta4w@+4c7{c|z2
z=3tCJNe<TU$rze4&eEn?t}<C8IoMh#BV%ax6<~}$*Bo=w4CZAF%@zX8xio`$*?!7U
zNDhv3Pv*x`fZ}iH$a^uTPbfpNHS~L?w$7`I!SONQDaoO(!OZ{N-I+s?aqh_k$Jy*^
zzN6kkr+Kuw^wO$}F}jnvP{pffh7Qf~4Vh|z5ucuRjC>F9RGW0+;aV0t4<b8q{nn`a
z)V3S7OxC+*u6H-E1(G!(ncMxc;ddJ|fmX$+>14+&OMPAJWPQ0x=~+saWr({M(*4Tk
z2=oL5zre_vuP~kf>Vm#}YUrP4S&qBRV+Qluh+G5tmi<~UA;0~BI({iBAk+6#k*Cbh
zW;vVXLYB>UUCO-dHAoIl6WKpXT*{iV{8R6y;}?-g-z>{Cr?HBLUw7(>GCk#dkjj!S
z<QP?^l}tCe&MbA#hiSc%>^uO}gjtrOSvd=kD6LKA@uWGFkCv0)=`ONU05tN#tRqLE
z%BE>nEB(qfKsghXD}e#O7E!U9Y~IGH5#Ws#b$O@KRgPE9vROYgH7Gv17|&}>G7V)6
zCCW7@TC>7$L{<^LQXfF`+LX)}8Lq5Z6fVXFT!W-6T_xV(qj2v98fhihMrgf7`ZC7w
z=J=Z}$aIsbdM+IqD~XSD{AF6nQYtZ^gJ&x|+6<(CG5(jSB-8eMWOF=2<<Qs$;vnZN
znviiI-iVddk@4?c--xZ*mkeF%2f{T<)c+kL(?O=ZM9O7Z8V!_;Irn?Y^m}dO%ZxIf
zvQ3b8y24=>(IQeL<CnOS#f73s48?h*SS4ZwelJg~$1y;}gPSORCo&<=!7*2y#xX!-
zfzO6cHsn&s7r|dS)-#qsuE4PzhYQwMi2iUHAl&%Yp&RF`aJ~xX2C-lB;PB$wi|cjb
z9c>-X>%~!RJ>>O}n?#q^gzF|;H}UmwaShHJ#3^k9&Ku#j5pEkHZxW}q7Gc#}z_oyD
z0oNjii_PF~#IXhO-U9A+xZRH5X}A;TJ4Kd$7w+wD#PuE=_u;_rjcE7d7su`wdD;%d
z{I}p<6r;2k#SWau;_SjPKpet1wGV+iBwoSUg=2vD4BThnJ_Gj|xX-{PXbZv;U?~B=
zv7Vs0v;_RVb|Sb$aEag&!6kxA0+$3X30xAmByetx-T_#{*aZAp|BZ~TjCV5L$GC%W
z7cfse4%F<=F!Ma)LB_+3?=l`|JjwVu@Z}MjPJ6^7fO!I6tpY~is}gHQ4u`yMWCHMK
z{UZeNTlrVW$1t-<qpuI`6c=4yqU~YV$*i9N%oEv+5n|uvYeu$;W0yN(TE(ZAKR#d$
zG~F?4#F@(*V-`VYL(E<<XN5z*b!i)P?p*p9@S&y0#76P>(%;4$6rD@|fX!yxhuZoa
zP?~>U+7)w%f5q|;|7z+HLBE1}h<`Qp5Xa;Q|FSA{@J_%9_H_j7Yz3NIUwB1f>}l3H
z%{r&q?-{m#nsrX|8xK~b%vsS_D~h?_(kiaROH-|);fmdQt7yGqBEBQ@!l1*kt$63>
zz1WTV^os9+c@@|zqAjY}tru(675(A}FO1u$H-InJu4U$0FoW1~lenb<->B6etr#2E
zD)v^S$3-*m&<|AP#2pr0)}_F|S1bqqqoOu0S^K!+V(qZ_szUPH!C$a!XWV%B$`j+Y
zi!LADuT{h>`)yphvJ;o{$GA)_W7$V>d0OEz^1EW0CB9gzU$$F6Ebd&^H~z5r&9b5K
z2X)%zl7O$v=ZVAO-DRoqJNZ4J9fH2OSE|u3ahGcJd-3HOrE|GPDOrk8O0)_Ny@L4)
z<|{OMx5LSCsNvM}vFyX|@Y(vbio7c;5;ici8LrbTTR4VWIfj%wze(7rZy(y3u$^@r
zdc~FRC+yVdw<&jOu~$ST?%}X@YV-@aJE4;&;EG({3wd(lerEQw&VG&F7CFFn4slEl
zi<hr_I&q_Z^2!$y>E8du_+jEv)>)%ZsLV*xxKvZlmM5KJ-k~>E)+8N8{5K_S6dNij
z^|n>snnd|>chYIjmsa5@9-Dkv&^vtZ3aS@pl;7H__Y)ktuj=AtD@r?+^FJ@WD!DK2
zaZ}PDt|J31bQjTJF4kJb?T!zVcZvrbRU`Up^u35=_BEa{oiUTqp+D&;PsvmA9~=*+
zl<Jh%*+|b<Q_6M9@q_v+%k#uR$OCK%9LgBW<<7sRjIpeCW}!S^@1*j)#raswWOmH}
zex6dH)9?0H==8h2#mpC59w_NEig4hl2>y*mr@q^jI?AaZ9W;4V4a+qwJN52CWnc(f
z#i|vzjq)LeC7MsC_eWaAO)HLx4IJmqj6R*-B-x_VuLE!8G}#V5Pi$vqyH0P2>;&^1
zzTHB&mvKMi0iC{9azLlAlpN6MJ0?dt1y1n2I}r1q^*_bTX=cu_Y_(9z^tDi04PrT(
z<z$w}qa7$4t!W?NtC10cz5>2Re;qY_Jgl7+Zs3v8Yjpd{564goIUDUH?IRz<?MXVP
zRVHJeh3aD|TP|nI4!vk)+Sm#Uy<z8s&JxJfa@Mepk9F{#Hr}|~&+XM3%d(Zj#x+?Q
zR>qGTW7)X!?bywhqLo!6wy^$I*5A%yZD!o5kivE7Pr27m*vZy5Bb2HU+u84SmiIvO
ztk`M!b;**kefg^{4*hpyw@hfYbh;k`9(2c#+iU5E-+bI_x#Fsewf(GrfbkIHK~a6x
z&(kP|?P&+a=8~VM9kHyw>fN-X9Jdo3w{%X)Q+&Ut_)h7rvEP#M4C9@^pY=audF!gQ
zNoOqYUo{i>A<$~2-=FMj{p_mY{rXzJxhhNawNi@pwO+XTVr`I>eziH;x_xNh$%Cx)
zJI={gDg((@Dg)!8iT03n##`wfm~=2_MJDjM0pnSJyp`UDNoNavHS(LsI&1Xi)elWB
zwbJhzms+WXDP?P=R{9O-ax4AfGZ?(*Qf{SRN#0>uc*R?jcUYoo{sve2<>(65uVBpz
z)@c<(Yj*1uR(g-7hT~A7H0fQMor1mtzk&4~`pTLmQ+5h^KXWtN+06WAE4?AJ1<YBo
zi&Jc?m41nStChYJzuii0@=mx;>9dD@?O|q*mEM8b%f9wosTbR6rIviBm40LWfR%oq
z`hb;wpZXAVN`Ukx%pohi9dm?zQK_(|A7%Lj<0;0|z!L2Y%MQJx?w{$_Fp8T)KUJ3#
zciKv2<}`BfQmrrZgOqD~!}<xWB6iI&@gGsL=Id$E%qJ^X`^qI##)nZ}j1S{{1pnNC
zbY{|-NoS^2jPO(>w2D*@S`zM4GQ+kH9o{bwu6d%Av7E6Yj8ds0>=)^swu-P_>1X>^
zggup>qdA#(GVf&Gsd)MtG}Uf>hLv0UVyz6JP_O#u8LeU|%U3ZrGH&!xUw?<^``BWw
z-E(wCvG$awGoe`fgQt7O3GUZw!l<<wZ=tr`7e;m87e@KJ0dcnVS){!L3mM{F&(a9$
zov)mEScH3bqGun#IL7M&Q|PUoxh0Hxe;?o1Rv@MJTi$=q+|Ke&#yw&5d*6G)==Z+&
zf++#g`!IXM=pC8ETypla<^e{B9@cm&;}FY77>|Zgt9XLrTx`i{ynWUw=1+q^JnIbe
zr^Bd?Iuq7`F@rUH`_QTplks~6cl6IdtMxO+ZT*jP?amPNMb^IIA2y;chjT3s|ELi)
zI-GK95My*WrA9Q`^RuFcTa0AzXT^BNbVi4M-`WRLGQ)W!6He(_ig1Vb+rawK;gqV;
z;nbG;m^q2ixAiY&zf_}N&$O~kW7HvY%2}rzOnAQvCDXUWE0}RI<5Yg_D<kKw!MM~O
zR>MptyP|hOA5qHa1D_{+d|z9b*?^b~@8{#Y_VHbB=9q8cm~UnM&8+z!@xq`r^R|c6
zFQ@Nheh=`u0Xr2#@9gXer>|%24X2vBH#~9lfC2ki=K%1m*vxGg>fm~7`eu!4%^~KG
za2$??Q*AoIp`YT=Pb1w>bD6Q)C?)qICdd&R{hD@P8~sjtUmLx#GRQ{uqk$Niuxqr9
z-g1ey(c3M_>^j~?zoI^#b;jH1ch%Ev^c(BRHY(dk!?_mQ=slLB;ne<QvSudhWZLN6
zm(v{EJR7Chc<%Mm8Ov?MCSbH_Ta&eKK)Ee^!o0|G8{JE}jefPX+(zFJBiR8Y%jLG1
zD__qkx6ya9DmZTCHu|<#xsAT!<+Rc7yw@OB!}~co4o(}rK~v6Q`8f3QaQY%@c{qIu
zwLF}@&gewR5AU}De#hl*mVU#ioRo)CE3tv?Y_QSWHWh4V3)|TW{g&JcwpPK`D%e^@
zIF~WDxt*<TWeZzv^iGbGE$n0qdu;R@^n2KKkB#2S*<+)(arWA%{O{*nJ7A+W_JEDr
z*m4_<5)ZNd5w?8DM!zmjJie2_{0YWWj1Il&>ZTE=Ijl2m(`x4tk)3kkw2j{KA7rQB
zyN|Y0nh&zmuig)`Z&>)xykt9-hh%1w6+@akb^794vYp=W84te`^V3-~UCH!zPo{mr
zLQj64oytZjyOuIjYNvO2%E6o!70`b^-^s2{CDU6xHTLfoKbk!VcW3M4V^<$DK0Cd~
zvjOr;)2!U0Zf4ib%xt#Pn><?}=M`+_aJSfBy5`aBEp~cuXFF?dXV>j^daq}vol5LZ
zJAE;356gR4-fLe}{=0(xY~g4)rRo9pdw}@^c6!sNSbJf^F>%O#+XnQiNN4n?taHe|
zVZ+G6McV5dW)>c?FWO)!JY=Uge2&8PtT@3sCzwBBr?-OkGk?nND7S~5ve%a1Qh1uf
zJ;R!3m_Nh(89TiVWR2KV{_@P7eDBtXss*UU5tK)LneVF@dN*iL#NDtqh?!{CiDo8R
zG4zhmRt`Nmg6m_%mIdWSTQEi%-Y=c?)0s(+pf`pxStpN~Qg$t6xtzZzSQ<fZ4pl^0
zm;9l~89^3mSf_@Wnh1J#$j25i&$@1+*bp&ti9KvH>ugpsy+gDm;^~X>inqeTrljrc
zx}BNr5%d<(PB3T19xx9U?}d)7&wkd~&&>V^dYkA##B&$DReXpo9AVcZ%p8fJ_lb_O
zg%e;Vl$>G<r&;GTGp8fyy`nP_8?Ub|u|~!&Sz2-?!d`QANwlE4+&7Z$>kR9kiJ&)$
zF6S9vw4jz`P$cETAog`Yr!OZCiljG@qQRdP2Xy*oU^45BkEHT8K9bt`^vH!}_OMLm
zGnGtl5aqG2(n$A`Z}f6@EmtzVLsY@8PR1HWO{1?cX<ACNvoslHV^dNzqc1YQ`LWUs
zY+-|v>5ZWck@ThzjeJfGZxt(=kBMi*w&urTKDTrLH?z$(`iIR~Vx#^AT-WH<jX7nl
z_!Z2;GR@L|<KnVsbPDTvedxvu<L=ZGH(uK>TU=AzP<A=SQF&rZ<iZl0ZA;{elF|`d
zBdN#V8hK60?PXgdsqfwzNh6A_k<{{R<+yE+q_%EnB(+O>BLBVo8+}jYM~t*iwI}k~
zjgOS=iR^y~;j0@l=7}772_e13v?ua|jZc6-#{6Z=iKn-X_C)ggs<8j$(7kM7FZ<ok
z_V=^>{p`A*UH7y7{gGLla<u)C$*{kl?eC8yoBJa#-}FS;{>Vk_>fD5HeX{)nY~cV~
zIKX}nvHe4A{}8(#irffaha$6K^HAiLO%qBEMHXH{Nbx@u`7?H<P>!(v5!OG#nyn(L
zh1SQ84x%w|O4@S^`f5~iveAR&3A<<(-|Kd)ds;1aakGf9^cVMvK4EsThxx}u1?0W#
zI$o;?>n{#zizDq=X(eALz}Uq<HS&8()BD)Pf0)m+kZX~JTrXm|oaHl?0Z{|R=hpA_
zfg(SWa9KaXTE=S`Zv)!JYrr&7Ek0S8hBaL6qBN||l6-|Y0Nf_7T9hUhi$6f#jTokh
z`HZ)U2x#6VT4K^fyYND1wfGh~BgMxH(!@A1AM#Xj8F03^9+-=#BCYsUxt5qV{O<9!
z_*iZq+)=yuR(ufME-a9Dv1<ohM?`lr-^n_i?0S-2BQ&zmqLJSgjeNCeWTBP$U5uT~
zbh2wFYj$b-#Hg5)>>8nyg#?`}H0#8-=yYH0jL$RQsgNvp>J-XB_H~^3lPqf%vXH>o
zV#y7w2urdOj<L?xo=MKNlFee4tF2_A+DiJ>R<h}4zJ+z#*|nWr+u5~KA^GZL{y1Z|
zLbA}!zO*p186QS>k-&0p82QQ#Bb{7ks>80a{dIH;bRHbj&bTX#Qs5w?2qy~>;l#wV
zJci{gmUF||PB`0Sri!tZb=txy++8f6WQ?$pooXB1`%YUQ;4WqkGIrZI<~Fj{ZKH5c
zuuig_G@Xnsc5-d8lWU8e^xIi(S2DRCV9jo3x>>)Qbu1C&%Mw94mI(5j#7vTsiBFE8
zu$q}~i=cS6vwk}>?X20s{6YNYVM|OG%O_bDk)$8bm=sC5oW*i>B!yeWa&_dJk?&7w
zX1RssHkLaWyCNyYx>>(FlH$`HN%6Gw;h6W~nD-$jfte(hlax%Z*(`7DvrqhDVmr(2
ztkceZk2BM)knD6zn|(Qyz8p$lvXi8cm?U<sR!FYZtQp^rUHk15ku$Pbu41h2$2v+T
z%grqB>PIPdpdY31L6)`tY@t8tBq^Ew_9vUp{-oK$d<*Ne^e5NN%okrk*4&H-8Ba<k
ziuhK>_9(L49!0*|qbRKB8ILobWF2h)@eu>aR|3n~jJXQQLhb;vP|P|G=G`oJ4j|V~
zcI{;TIAg>>vNnb>cOY9BNEUJjQdkKW5@s{zUPxueeIdu0vHQY(;^%qY%%5b&GKef#
z29YnzAhHuNi1dpY-Hh#n$WAxoNoFDjlTPkn;;RRfuj;{Mp?WY`bF*s;ySB32$$Tek
zcCzL{=8v=7&6+2fu?*q(3?ZAAA!IXm2$kyUArw~Y5DK@Q<y|a4&pO8$EkoJwQ1&~N
z{3bDu8A`sgS<YoFW~Pc|2V*niM#dJ#HpX_wPR4G=q+w(^YZ%2Rm*r~4jf^`O+Zj8C
zQH^_^<xa+KM$2%H8)G(OE@Sa<if7euPE}^y%rrC8!b}^>J6LXK>|myo<t~=HSr#M6
zj%5Ue6)}P=$1{_}%ot{}n8{_Pisfd;7G~N;Q2g6j?quv{Jjs47BiZsuvYf<nE@Rb5
z@>R`p3u8NDCu29Gh$bCNG^Yb&E~A67nsFmz3*!#PcE;x!I~k8Nb~B2YeWGQwC5CM>
z<}wz?Pz)U`S2MbqX@)-fUuN1FyBRI9Y=Lo1Ecq>FtY)T#v7PZaqZUW{7RCg|B*tt;
z2V*tkM#dJ#9gOXa&og#19*m<9yIDTTvKG(w8Iu@u8LJsv7~2^;8M_%p0;g~S`He{6
zJYsna%egGKFt#&xGIlds5;+AJa~Z1{TNrmRwlnTZq@Jjg<%2ADvwV`}ge11Zn9Eqr
zxRJ4iv7ND#v71p#=KE!gNamQcJci|5ma7?C7~2^;8M_#}8AS?}|M--B;`XtQ6tcMs
z^0Cr`DP;2`<Csw-XOAM+VwQKX{5)gVsD0x3afB)3B2r0n3}aR*@q{zR6E=*`P9+O%
z%<o`1Vl?YBYGcSXfl-X5d=cY_X`aBo7~|7O&SKn{_HEcVDLWYBC+!oCNm)Snn#?$b
zu!FH`D#_1JCH>=!RnyoqW7{-x-8h}CF*eWGCw5M0o<X_R#@NBw#h91T2PxK-LB85%
z5oXP1Ig@O5Fm^GDImE;>W=Wh&Ox0Y{Z=OdOpT(F>n3cn>jBSh^ImBBFIK%>yMG@&V
z7ZbKIb})7ov+I1~;~BFgma<L8X2!Ns(yS_DJB(ct7ZH<n@fH0s23tZQIvL|HWuCE$
zv6-=hG5#_R_j1ySXLMdpeyvLhlNqy?l1|$dq|?FJ#V9J+7h@J<6=O4F8)FA!7o%9l
z`ixnO9aj?5TuIngNulhlq;O9#RxM}VN&EpP@og?*IvC?uvFzRrKK?3_vlyFKvoDGD
zBzLVL9pPb3#w^Av#%9Jg#ty~<9tx|AW#MICj9H9TjLnQ~j2(;zyzGl*;bUKnS&UVT
zP9Nzsv)snm!Pvzp8rc_P7Go8ovypwV+`-tzDAuw*V-{l-V>4qLV+Z4bwPc}-Wr0sd
zA;lQ87^@hY8QT~;7`qt7de&!5UQc$iSgvAhW^7~ZVC-TPP3(&?xru$TT*cVT*w(~3
z$asKtx>y!h6Ccl*#aMMUmw~Iv&Vg&#+6L08Vmz>c7;)`BF?@bJW5>1Rdf-~(yI79D
zZa2l8v5K+nIu4z&i&0!pOxE?JS;g4Q*v8nw*u^NCNhh8$i?NEanX!$rgRzTIY-D}L
zEXFFvX2v$g4#qA<v5EB=vly!wn;F{}I~cndMGNaQW-(SVHZ!&{b})7^ip{Lgn8jGd
z*v#0**ui*U^S_dihMTDu=we3PKz_vy#Kf~4&vF*ac{h-L6*E=LIGJf?rkR<n8#(V7
zJ8mRvU5w%;jum6pO_bwZEQ^~trx?3#CSKe^n$3)Dw-D2eAH6~Qz}Ugq#Tb7ZYcjSm
zb})7^#{XoWC|r>B6Vj<-Y-Vg@?Dz?V+r`*%JICj)SF!#ewi0GBRx!3Qc1Zqia&2Sm
zVC-Vdx`+5G#x}+dMsY9k@r-TTNEX|fVa#Iecz~HU!Ysxr#<mBE>0lJ?tixEv*evle
z;@cRz7{%jkhp~#Wjj@AKJi&Gts~DRZI~cnd<DX;;jLnQ~jQgYCjc$n1Vi(5ljt!5?
zh`%NN{`lC0OB1#wJeBZD!l{JWiMJ<yk$6GU=%m+@rX;r{N2Y8{*`Css@{g2{QihMp
z9<_MXYomszE=@h0T0Yu0`nu6CkN$W};@Gug9TV=EuxG+k6ZTD*pXN@xKJC`D->02T
zi=Q}c;^K*$C*C`8$)qbLEu6e!^18|Yn4C0a%9OcNR!`Y7<rh=FoU&%>eN!9LQ>RUx
z_T03?)6PtrI{otL8>a7^{@WQJ&4`>iXJ+}#+h-<c%+AP|b@8mLX5BsOg<1caHEMR|
z?3~$)W;e~=Jo_iJ<1%wIFUq_$b9LrznZL<=EAvF=zcR<q$(wWKoEzu-a?a~>2F#s4
zH*;>`+|s!#=eEw>J@?Suzs>!6?(lgz^BnV5&ug03I`95@U(B;+MQ4r5nv+$N<;i+F
z>y@mz*<INwIWuy6Id|vm&WXvrBDXQOGxu0-WZtB_pX43Q`+HtW{w4V}`A_G+pMNqx
zs$hD-x`LerUlzCuuPc1G@Y%xd!ib`zqG?41MVpGADEhD{qIi1o&x#KgCzV`O@?goU
zC7+gjRbmf&X#Rou|D8X+^s3VJrPr1|RQh7+8>R7O8D$H~E-R}lTUFLs_Ey=4W&bJb
zvmj<c>Vhc?vKQ=K@W%!3E{Mhc**Lr_k&ZWY=U`QJuIPikuKlr3H46JuFU0EQ5bP%%
zj{T(3;tpuuiQRKTyc|0O_(|-D9`cPTv0%2PBm#evG74xJJr>w+bQ*Bj=qbH2W@|Gt
zrbB0O#w_59jJd$`VM0R*jmdzyIj}Z*ZUHbL(|0f|*dc8Nh5^IzmU0C4^F|^a`r^O8
zxB&kbA~gmhC5B+{@NoQ(z<-<=iCx1nNRL>NjH^^!jTcE`f=CgQ#3-a_s+b|hB2~v@
z7x4s<C(=X__81q#wNy+NWnzk0fK}Z^&|EC0iA%(EaVdOUCT5DIB12q(y~q{ty$pHc
z!Y77nVWk0ivj(fbK3Kb2<csS>0rrj-BA1H9O|X26C=s{8`t7iO2lgs&h2@`Nzw$lU
zuY4~;xDO$0LkJIu%f*8T;UR?ZON8*Ss1&<JmH4%AV9k8Fcp59%&j_d3kC30k-sVoR
zQoMv+!Y^ZA^Fgdlzar|yYlz98gjc+U*t{(o#d~6{IEr#}4CUs1#P08iSvO+#fw)2Z
z3$gnctMs2BhM$XDd5`kH#ZSa{h^dbK$u{k$!miyV`e|Fm1=`&rO1no4(C!rjwfn?{
z+IBGrdzA-kzYxQ;HW82A!=tnZMXI(_jMILJ{h+(V1Z}rS(|#=`YmbSU+7n`q_FFMe
z`<=+b9_C!_k0KxYmJ9JC3B}q!#C+^mF2nxhg<7Jv2>Xv0YeIZAs0gJ(;;#ndwOw&w
z@PoirLmmb;4B69zd5oD0haLwn(X1antf&5;nK{LnJiG!Sjvej*hWh<tIQf<QQzQSZ
zqppp78~E3eM}eP={5#MRO*kt03qS6QA!`R?uCxmA-vQOY-^X?W-;8|=_+Bi<b48p5
z-$|=y40R2S$&>Lt@8ZD(V)ikb@AvZ%W?dp_-psg-@pp`7Ujvg!XI;_<;X+)W^bxQ%
z>2u)LBuXDMFB$3jauTJ<nWVusqzub4*KWRG92kk_P%@J#l(ys?xISg06sV1&u-2xK
zzO?y5)K4Kx95{;7%FJ{}Jq6dVnSU#Fv)xGfcT!s+A5Xm<crx{F;Fqb}fMbX61fEHy
zQ2tkabIc1yQ_N+)gyz@J$5K3hHI{PulNgeJ$IO1lR~gOL`i>)O$&6-x5i@rWs*Dgq
z-l^I3X?A@j#8?0EWX-Hu!OYX+ABLUh#_t1$mZ*ve<g1bKtB5m^MoK!<hV~IcqV#3d
z5lTsOD1S*K3*RuB`O=9!<MVT7o*TalmP2DA<8W|NPhU$X_hbf6A!ZKarHq>x&7r@{
zj10v!wXAP&oPRf!EUZp{3A{J`FTk7AKLwgg`1zFl57MdROT26v<+wQxH%y~Y7Eb>~
zKOr2`$yL@1v(A^(Nv9uwI(P!3xot6Pe#EYpnWUdQoa&maJ3}w<^cP}k1~Fz?x;~Im
z1pTqI-hxi12_+M%Zw@hTHiflpHdzQw8MEdC8Kh~h%l~U#Gh0iVL)NA<%DQj1Y;Gka
zZ}$7$+<@P~{F!BQizL%umI`yJma;SJw*%0YhP2zV4Uz4MxrLFf%C78%1K}(CO5p3+
z4M1~zzR0Ec#N-jqU|h;5dkWbW^~s+yREXGoDj_o6WSWbDKY+h=D3vj@&4Yzx&CDDs
zBId7*A2NQ+ctLSb&5xOhEFnITQP%N0OIBduDAU1gd2K0a{;`_kpgXCIO?OdWP~f88
z&EcjNRr2#4#E-8f{th3>_xgJ3e7BK!so%RCg}0yZ#v9&+qW5EI9B9W|O;(Kc9t4t0
z7>-9VCXB+!C>%^*j1Hs3lVI)Q2^>1EB5(}SB5`#gP{TV_eZUU@+A(J73)dk)9b?FT
zkcVmg!4C!M7*SpTd72glemYRY=yCw~AwWCEF$2M80Ch2pN1&P7An>z+I>w!Y;aa2(
z0aFOnF#;V5xkMWVem+pg*mF4K1=<MkWk5}g$Cy<Y<A713T8jq19H?V-8UuNy77KnA
zP{&v_4sw$o4}LvR$H+7R7G?tN;%Yq+uGau{j8u~#U#lmB-vHFbER2Bd;s$*b_#1&b
zMzX1pZ`MbHzX_;gTssDGt3DR|EkGS3+;L!@)W?I_3&eMY5HGuU3i~Od#BYH*My(SO
zhowNfcv_zX{&zqfBiYH2Pw7*@e+1Mqrkx7rQ#~EbCqPZqV~nk1+&T^X7y5MYp93|F
zVrPJF07i-amYLxD0rBNi+!@~V2HM31mRWF(0_qs;&IU8Uk_l!Y5Z_DUnbTm)Trfj`
zI!40tAP=)-L31cj=QjwWM64wTObk%RC^;8$oFxyM@j!eh3nO}6T!ZnvE`E;DJl-f4
z^MP#`&ExHEu@LwW<_q}l561O)qZ^}oT|AC4y^hiP<-nJa5*kM6%OJnZ_zFh$y7&vm
z^_qAGqk0`<b;5Tsve(65F|OA!YIg&VVO)<d<^Xk!-)n)#k!Bjk@M|Fdo$&-xMaPJ~
z5%>>`^>y(f?nB4e{u<yX;#%l`3e@p#;Pt>SFbB}ZmzV|U81vr%{0cJxUHlt6&GD^C
z%mj4t4Q4F5_%F=_uutVq;CI*wql@qHz9Jd|%mna#Jj?@h%o4T%BQO`xMWprs!s-J=
zt;CE#7yY$%;04-4z$oou-~h}Fbj%@k14n3&0;9Fx0AsbsfpOZCzy$3nV3PJUaGdrG
za02$X=$K7B3!JDu2b`om51g!Z0;ga`p^K^7OTcvPAaI`cDlkiX4VbOH0nEYsXFBE`
zZvykQw}AQD+rR?MK=5T5?LEYNv33md#f;_J`;afyjsvT-ZlFv10JuW?5SkwCB;+-W
zUhN~ujoQb+wc4k^tF_O8*Jxh?TePpBe}ncl<jssXYX5<J6ZY`vqE$N!*ITvkA>YEd
zMbk8V&lh`pbaA^D2E0?V0e`ARXqvbSh%b_8eSmjs{ebsq7Xa_o2Eg?`AWErrA#l4k
z7|buUp^)!qd_Wrxd51O<_@EX8+@-|<e~o#UCLY7AOBcUkd|XR`{DhVY{`cA#$j>nD
z)5byW&?W#owTZx&w8_BNw5h<?wQ0aVX*1yK&sqlL!;EiYSCTG{Xmfyn(dNPR9W5L3
z+l=pOxscz}@_|RSLbx6S>f&!&G4PZ&ANZM820V?~A<8P|hnn~|5M>qfM3hx+3Gl3T
zDfsWT%OQWqDD*2J>-sXFMX!Xb6^L@HJAmPOHPEKJfOdT)Fj98|`{=8o*%zpbetIo%
zfL;&gLVXS7fs8|SFPPzaBbZ@~BlLBUqxB|WjD8I;R=*Y)uU`*L&^H1T^%h`~egiN?
zzX>=>Z-t%F`mK;t8OQ3kK_0K)4xFgp3D;@*U69imXX<xD&d~1xKMSaf+4_CJY<(Lr
zN53DKuRj31NZ$cmq_;!!Vj#X*qdx>J*B=Hh(RTqW^xeQ^`lG-V`fs4QN`D;kN=CQ-
zB;>2~r+};Vr{P)yM4PNX16-@`1FqAb1-9tV0XOT<18>zkfj`w>1m35=1pK*v5cr7x
zDsZ>{8t_s54dAc!!@%F@ZvtP?-vV~(ZzGfgKwZ43zYBa>e-F$-pe_#S$AGWt?}K?m
zKMwhI#y9nDFmLG}fH}hW7yU!XZ|f(4@8}-^kLn*o=WqI_kdFa1(WQS5`F+OY`j=q-
z4%9`r{uSgCjQ`NT2J-<>6aUoz1NlS7llr${{slxy)6YT{mhT~duM<+mMX9q`fMJ#}
zpxt5vMp`0(eJp)|eJ%ZfNtO$Mqbvh}sg?_MlmwtI##jae$6AI0$61C0Cs;<pH4TVT
zVTl1wv%~>2ED6AQmLy=VB?VYuNd+#oi~&|!#sRA=6MzoOMBw$7$-qsPsj$`pM6Ow;
zLB4_UCd&*kH!|LA$$;EynGL+fG6#68WghT|B^&sbB^SQ_0z^7n@`3MI3W4uhih+N%
z%m*H|lmU-f7DDrHK%};15wOd$7|d}X`Y+28$lZ*eS}q0i2~ZQ?ST2YBHRBZP6=0?U
zQQED`fSJ}xFmr&qm}_+ai>%dPN~|u(#f<Z<D<PL!-M}*IYTyEEEpVZ=9(aj$4e(N{
z7rrh7Vhm$#1TM9%172Zm0)M6T8pxH_Yk^l=uLoXl-3V;9w!n2G5GiTB0r;TxCg4NX
zR^V>yt-w9j+knqnZwGc*?*#tMdKd70>)pWbt@i*$*nPlZVcUQs!|n&(6!rk{marYb
zJFr_*7k7m{1iUZoVc_<#UHbjvoAC9P7ez_L8uWNs5vzeYcysGTkrz=5xgeq*SQPOl
zn7I*d?U3+A^wAHAwa`2y)<g4<xH_UAm<`Z8B(8(zA<+zLpNZ*_gySPu1Jfc8W2`VK
zvY-B$m=akJCOz^^Fk>V8=n0y=&!yoBT4bNq=r{WIIgH-Af1k_2MD?i$GqBH_U<UPB
zgO$7y&`i{#p_!<~LNgKDOfCnL2+c%n!FUtQC}<{W<Dr?Pr9m@En*_}yZ3;A#v~*}D
zY15&Zq|Jn8q!@%X?_}|s^>5Zywg%gJ+oSfU>>c*?{hRyW-2aiNC!(H@ek1zN(Z`~<
z#Jm*qR!n^C*x2;gIk9=Mu2^5}#@M@KW8!AT-5U4nxM$<K<GzZ!BmO}A>+$cz|2Muc
zVR?ct;g*D-CcKd_JTW10Ok#dwSz>MCtBIDR_@t#tze}2(T$y}(a$E8X$rq-iq@<@5
zq^wVQBITJBZB*Q-j8S)u+BWL9qy9DOi&2);KB-BmlTzoT7N?e{UYhDoU6Xos>W!&)
zr9PPYMC$XY>7%nozcBjCG1}P3u@{aVF*a*#+1SdlE5_E1?KffYgqR5{Cp1jhJmK33
zVQKMcbJPBu)|K{2+SL<po0u{wZ&KN$PbPgcY3SsX$rC4MPrhsNi<4iQY@ZS}WzdwF
zQ;MgopR#$%$tgpp#!XF~I&td4skcx4Z0fgDhosL;Uy}ZM`rGM4r`<BGecH(Bsng4*
z*H7Ov{ddz}oPKorKd1k9x;Asv%xN>PnAtM(#7tYpkc`P0Pi8!uaV#Tp*6>-^&AM^c
zW3yhK_1>(Q*~POjo9&qW=h@w}Pt6X`?4LO_^ZGe2&H4A7)VZB=-<mslUdFu3<{g}O
zbl!=1ky({lH)cJX^{1?3S^v!XE^BahYW9@u9obK3zm)xE_VAo>Ig4_Z<vgA9`<!=k
z&g9s0qjGa|7v{Qhx8**Z`(*Cn+*7$<=UVb&^HTCM@(S`U$y<@PF7LX$8}rWOS@UD^
zGxHbZZ^_@9|BL)z=D(5ucK$c{)`HlAu>}_wTv@QX;NF5g1+NtRrQpMYNrkzE^9$D&
z-c|TO;p2s`7QS8hdEwc@IYrBg+(nH=KP}o`^vj|*iry~zs_1M{Z1LFQ<;69{>x(xP
z?<xLm@pHvr7Jpl8E4iR#M#;RAqLP-9+e@~UJX!Kw$-5=b%zt<O@%bm`_bI)wbY$t=
z(o0I8Dt)$eO4&7KH<WEFd$4R@*=uF*mwjGlSul8kwHX}*=Fs$qzCye);*T_!hJ=Mr
zrZ8@~ki=ka`QT8_K8QH_BTGMR5!gE~W&R~G1VjAj%|cv+HAs>-LB1IQk^BtgJ1~PM
z`2)!BU?q>_aW`N+9V>q%Z-o4EUn#!{dDsO~PP<WvD6Ec<&U(mgSmz-5LC6#<lHY}V
zFCIdXJnSae942KK<X;V!@~<Gz94Y0GA-@wX<taDA6CPBN-v-E&5~REv@;ixAev|lQ
zDaW@8QIsO(8pxlGlJY^wlSWH9;TEI?9(9q;YRE5-lk&rmF^y&ZzmU7|AdGY_zEz0$
zNm70Ya?xZdpC&n7%5%5i{-;U#PRK9g(HQyt6mrx|DG#^}@xj9~;&UO#XG*yiax)&E
z5q~%2K6s)v05i>JaQ;1xeZc*=eip|cuyXJmjt=1SSZjCzN2iDv2Y@f){E|q-Y;p|d
zm9y~VCriAF;}DM5M7DSx#~YZ*{s}YH!+7%aXFSt-6L<vYw{ZLgPodt%JoOzMf5puG
zJsd}I9K-Q99Pi`k!c(Z@IR1{KTU;ql;P?RV$bN{~_dhY?Jc;=uJwf^iGsRPw6@HB4
z6X2(Kw)GjFZGDdCT3-Oa#H{%=j<0b18~8PjZy^5%$A5v}V!h`Kj<Yzv!|^@l*8($0
z4Tp}yg2Rd<3`aN)8xA{;2plxu?4w0$eR1xGqd$%da75u4fMXzz3vmp>F&M`X97Ayo
z!+dBsW~L+Xv}z>grqMWJ@YE_+`xR!Ozrxe3UFgG}MDO$@`klQZ8S~K;9HVfg;wcvW
z*~Jj9izCG^xSqy}DT63qW0}YJTx8&y&RK(K9cz|Y$ojcTFIU`vwLOeKa82i>e8y_4
zvRf&xWqpUbu2yH4I<Hjc7G)35gjs)wcpWuO;EfeJ>v)p5p5ygPW$#z&`d54%C3dl1
z6jm>!zdb4*&#Ch(>U@aL_-d!PksdH3Kjy{IIYOQLsq+Qe{1{4y3$!KdK0sX$z_kv3
zfL6);aHSuk&f_#0|4AC9hY+(gN<TVN`q5dYpHq|f<J4sO_@GaEK8?~7&ydvhT6KN3
zy1rW3zgF45PMw?8d80Nfp8VgS!o5L-dxN%=`CAo#tKx4}{1)wxP6~gE_P&$+|Ag&X
z#Ws!7$%?tROs@xUCcOtVErIUm0p-6<dv84PZQAkiIAMM+^>!$|9ZIiV@tD!E|8~Xi
zRPq0%IzOz=yHtF4src?v`j0675yd~E_{WsLC$v{<C_YbUf2pDP9Mb;drRzglq>rxu
z2LE*aOxgKN+cS^u=QEW*Unu?y#ebpr(~3W>c+BS6&c7A^Zxx?^EB+hBf1~(s6#rkv
z|5x$<Rs0#npHci7=CNX|%kpH^W&YaLb)-7?)nz&BtIPZ7tIK%xSA2iP_g8$B;-eHF
zrTBr0AE@|&iXWtx=TLeLQRiVwZ<x{>ru0TAeuUyjC_Y;8(Ta~&e5~SQby+`Rby-g1
z6(6tk64iYsD?VA-NmlNobXopJ>9YKdR@bA|^;lij^YQAOrtGAtaMP5XNs6DO_(_VN
zuEL+G&U2NW9Ce+?XR9bs*M$}tpF)d_Pq9UYKVO~8lzW+SUulu~TWgW|SZk5#QEQRu
zahGy$3YX<}8_raow}s36-WD$N`+mjWulV~F|A68jQ2Yam-=X*&ir=C5hZO&i;vZ7{
z;c$5$Z>jUU>ik}~Y%kvnm+j>-b$txiRIiSO%l7gErGHYLzYbUZkB#o%Dw6mtM2bz8
z^D*jroH|dm$@`vYlj$?jCevrK;wRf=I?PblGi)+_W+*;G@fnKGQ2cDg&sO|w#m`av
z9L3L3{5-|aQ~W%|XM?ADlB?WvZR5G#<SV{V@rBA?q4HO3ll5!9a-Xl<=PUOzn@snG
z%6*}7U#Q#{Dfh+7eX(+1tlXD?r+8he+%Hw}x?J(g6u->&P!8qSGTR?G-j#~4RD7l4
z9g24--l6zv#aAo7TJbK$yA<zI{7S{IRQyWCyA|(Nyj$_B6~9{Xs}*0X_*%u+D!yLv
z^@^`o{2IltQT!Ukdlm0hyjSs!if>fqu2Ge{b&6l7_;reJQhbw2|7+CsH7Z}OQT(-v
zzgF?rD*k#^-Z!dqi#p$+&NnH4Hz|KNDSxdt+3vL3WV>^#y1rFi-=?l_Q`dK@a&wnD
z->uH~DEs%Q`?^QjzfbY^DgHjiZv#)|>wZ;^A5horO21vDXS+(zhtz#^tMdoy{GmFZ
zv^}3s?b}J493Oq8_>UF;vEsi{@%>tz|D(>|s`FWO{$8CmyR1hRbq-T!n>t7E8SRid
zr>JwPI*(E3aq2ulohPdEWObg(XCboHxlo<wtMd}OZ0{ZFx>}uAE52Txy?nNc7InTs
zoo`a-+xU!evc0sJ(yQGr$MFy0n)2geb>5})URCGU)cFlQV?2!WgZ7uB7mG(?9O9c8
zt9?dng{Y6+pxqhkv+ao8tnG-c62sz_<Jc{h#62!H#5p0az|kp=#r?|uUEBuk(|Dh)
zU&3asU&4c8QNncFRSEyW*=lc2cm#Ui<8X*~62i1cVm4^ii9Xx)iJP_S6CW4H5_cjz
zhj1oM)~-!@Ts)NI5c$dZT3K=-j`>=Cven+2yve=`$FFfbnd}fTDV-uM#UbXVRBH{8
zABic{b|tUGF<*ORRHx`1Rj752%Gat>H*4cYuMcm+F)Z%q8scoZGj@e#SX_-|+~`gA
zJ7d4pW{)jIoL;v-5;IhvJ+@QO_3W{!EDuU^h)HRkq983pe=My~qw~0lrItr0mB2=+
zWiNiTrV1Zj-Zr^V+kxZG*juzSlfQ(#OW!eht&PH%J$8eZKh<Y*Ox>(GriLL-@9K2y
z!hMWR@5HR!Ay%Y+pxdW8MEtaq;5)^=ke`_LCFDQhzR&7alQ-EnO;6PyiP@}eo4yI@
zwF&XvWd98E&KaBRlqXFy9paOj)fVy}l~JfgWu)p+8AEY6L@bWiGny>lWps+~Adj8p
z5Wk<53cHiFV{t?E6SFqi2hQGPcjKs^{U`ge*~r(~4)OKu$1Nf=LwDe4!SPV$m$=7G
z_HQyb*}ubKowFIoWTe+7d%rmudLoWRIPRO{5Zc^#^+|Ix^kq1%$FT#)$2cyScZ+s-
z9>UAY&<AE!Yj<T0uvVuIux^^(DRw1S*tShyj-v*L2gfbAUx(<(o{qGfi6af%&hT-g
z9ilrY4B@_NojrDhjgGp!5w^rRBW#Os+&AYIZD9T_T3&uL@_ejq7|Q3cxVG?5@_zxp
zvtZ}v;4*Eu736Dk3kz{L#N~zC!4;s~7QlT0&KKj@0Qnc-=R&sv@^T!%v=57W5a%i!
zt8g^nSc`c59JaUP*Z_Y!;inmPn{mF8Y@*EEY<qN45z5Ub`#(zlY5QXSKW)jS|APBJ
zZH1-zh+ik_$SLSJ#FeFCT7B$Ly*~E8a2E(K97i&aG#ry~Ou<otW0QSz=_dP6OP51V
zMR^HB{%nE#u6}3iSzO;}pRiyMo-Yo@F#^X(9CNVab}n{JWZ|5Ra}l007vo%p^8%bN
z!g&$Sm*QB8W4X9PbKzKp;~E^-;n;{{GmcgqTX5Wt<1Xmli}O=BKZEmr9M9o+0mq9t
z-UWXQ=Pn%GIR1g-B#w^}kI!&EjpG{}XK)CFX3?BjFL7di?!>crC+6c$tcN(U4uaMP
z$4DHpI1+Fq;~1^otdGMnQM*H%f+GXR0`TS95j<HvqOHU8{3aaNX$jOkVl!D;y|b~#
zHCJRe`s!CWs?(e`HDa;Lv({bh@^iWM9(j>n?Q^en_*{lUnak&JI(&}Y`nnbFm5m;U
z&s|?vHQDbmr_o*Gba_Nsz1Me<!{exR`CJ|^w7ou0W3{i|v)EPRqVvTrZ+)Yu+U50o
zr7+V}c=aA{+QqIFqzd~Y&(+|nbGquPo5)*DBa!**t6dEw1S}QHTf5k`(v9F8o?z1k
z%@%uV7MoocbIe4k<LahM-M&@EJ@=wwq#<@y`5HYgZyNdW$JULzGkePQK&{?$9)<(=
zWCVVR+qLc@PyJdqrEW;DhL$h{vwE<xswrZz&r@HwvZkrLslnwWALdA^n=dxyS%Djg
z??EoCa5UEVLLIW}nm|^2kk@2#LA@`#2Dj=&Zc$FSJT9lSn!n!Xs`Dbx0=e!_If`Y?
zS{H2jR=Mj|q6ASfHODN}w_nL9OO*U(FY0Cr98~0*3SD(Blvw0INCGM+ms6_BoHNRw
zzfk6(<O@m}zSm&dU<1WA#NFp`BLZAS7IM+`ilB0*Do@o^3Zu56zRp$WQ+I<6PW25<
z3+pcRxP3;V5LbtCzSiM!JN%klBh`I}+~y^$ii(b+)Zp^?P`*7#Y$G=2q%&%AFI=EN
znH^2pL-7jStIJf`^HBX)qCN4aO~95B*`Doy;f3zjXhr-@OAd-AZXjUA?_w0!OB^+g
zt^n(gTEGissEls*I)}&QPkMhT;TYw)9V_e5s=2F?YbyFKXZ~8`QMPBL7j2-yB0fR1
zYCEYZq3R*#yP8lTREt~cUg7e&Yh8=0ks&##FLiZh|G{xEl!YO%uY67de~`hBf!j3a
zl`J3GPN(S(L~$|F*HKsPDy^?y-H6v?R0qMgPj+h7B5ER7i&CowcTiu~OXSa`+B3$%
zdOz&iOE5BSu7xPkT>5)a$#yy#e6ngd>YU5#*P}EA*D!W8mEk<Mx1rwaSY8w86_@zj
zHKA3LJ@#(S$fi73b-iqOdJQ#@M-;xN&QYWCs!7%3p1zs{XFUA*Jnm|r%W3Ev9l1HL
zi|ba@pNkKK><>Z}?VygeX9D-kAyt^o)@oGWZH|e&n}C*4!2EqcZoT2n%bny8c`kLY
zT;*HmBIL|<dHih(H`5`;Lp>mn5F_RwO{L+76;(E!k5b_712=n)F!P$~9JTIhv+H7C
z6Ut+c&Z;T+#*2$EMp(G~DvX`VT(!$F{1X1=uguZVz;(D7J^FeK1wvAZ9bC?!M#@k=
z$54T2G=IIj2JRQtvyNl#uJ+f5pqK|#Lt<s}>lLPpptRvpTfm4(O_fjTEHI8SIrJWp
zUNu64I#0D;V`R2wDrTmr^{&yYv7p;CX{@VrIgO^(Z0<+v;X<=djMdI}e0TnufmklC
zc5s&$R1`wXrJ*L2o~h%a>4%)An0rp@kX3)?H|;muV~i2#`U0xPup_{z;kQ3Y11?5+
z?O`^prw<x-(Fi`&L?AuL);b=Q`D-mlTXAaKR$NE*8zb2t7!>hH)fh1u^Dg{^xv!cA
z*o)mO>v+;)vhY7C1)}_;lReCWLdMd)aRHMYDGX`@X%H9^({RnT-Y1HU?v*=3zFRqr
zqeM}Xe=gSB%uy7}PM+pA+}lG41Y=kiYFg<pPE<QQ-c{}fKeKoh#?>@5Qi9=CMl83{
z<H0DAFASI9L0TYFXcXwz@n@Bp4W!Y<_4PfBF2H=-X$<WHNq3RQ)xZ%9j1m3aJtk|i
zX`oq}e@-13&h+jch=kve$%-*14p=d_J|frcscx)scmjEohnb@+&F6FqglN=iHA=+{
ziYJa}I_2mO1?xwMfGwT@8$<CWb?!Bd{*{j2yJywY_w0eq_xIz?xiZ47ESjmH*4AuE
z=^0I**~t`0@nWCD<Kuy<oHHW<<N^qf%H@I#=9FfZM@VKOU@wq3i`_J|_qTHFXEBO-
z@T^=8N&Gd=m^R9yXsiGQMj(NJ#6|U9H$~A=6DX>jcWQmdzgD0!)EQ9Yd<(ub879}j
zW#ERgy<QB6YMKIWA|HcetU?**fNr40GHLfln!VJx99~W^tXVB~tZ?OFa85VqX`)pZ
z7fKgqS0;Pqn7pGY2_4ayvqqHy%wye7%$%L5kqa7YYO;M8`!8?wosZ{09BaLpiPX54
zi^WY?n5h+VoG8j^@CNG+QHB*BceTUoGx|S#@gTphu~w9qx@+A&Q65|#%7bFcqf^zW
za)AsqIOUl2igKQeqnVVGU)39WM4;UX+|^2#uQJc&t@gNisYI05W7&!t+4_dc{56e8
z4PO(<#dSzmdBwCB!((5O!@DZC-suu)+^m@G$Qw@!RBvyZ8kJIaV9Kw`2HDrrT2L`1
z0ooVL22o*gD{582?Lo#;OjV;xy8ZyLgsS9Hcioz_{PhhUmshTS1!R~jXsoM-nF93Y
z<woOeEYO$?1~So*${cl$mFTlzmdC!hHbN|{sb7vnxmrz5k*Qdo<e8wMoGUqweNTgQ
zM~1uCBon`+j#8n#K6h1pz1LOXsjuZCgO-B(Y`Mzo6^8foR42=2NFChI0?cZW&q$71
zhYz!gUPxK!TprclRW4Vn&gR1CrSv4T#a=Z(1c8~18v`(u7k|Hn%>6M1m5YJePjj7B
z^%%urX3dMbuAU2zQsEqqvbqUg3@UW_$S=#qb!+QayReSrZK}hx&x;%qEay6EYL+{y
zR|{U*P->WjD~axsjQsFowYd`fZ`z2X(LQjwS2t&-&8yS?3ZNEPkV~$bpyjwgEjQbs
zg*usIb!(}yqc!Ye>Vj%9dXfd1?zGH}N>sPfh!F;1=hE(}SqVi1QCVv=c4Ut4h=cW8
zl$8Hc<}h8F%NMRu1XK?9bTkjkxs=cndQknSTp=f;)SU7Y6v{laeQ!1<UaG@VeK(dk
z6d?<~7X^t|$vOJvtK9G-dpOj(wGMX;x54M)x!IYDe32`%qH?8wc^tXo?_7-~gFus|
z?pck2P|N(fCLMV5)6^vM%DYP~#EbGks65D^97aP{Sshs7RSzA^lz)1Hk-yi6mXjR$
zF%(9<#!$l>#0Hvh%Io0L#C49Ew_a${HszO!47Y_LQS71Xk7W;SKd<ydBi_Ry5cggp
z7#cYf;|~g4XfP%+5Cnzo@7j&|H1d|KOl755fTt1EPuDa$UFt!QQ3#8%F79#pN1>*c
zHOMHBABi!SayfeJ$+9YqlV~lprilm0a+sXcWXz7#q)$!pFLIft6GDzsjfsMPng*qF
z`ZnfT=Twl9C^sexsGWv9*)L7;OH&08faNlpSXk$uf<acvOk)}U1y<YwLkP750M6W^
z2Qr0|Co~ny=?Rzdz(}^2#a^jKlRJMS!mWkbyI1fytq3dQH7*b8mBZ;&xx^kluG;#w
zE;EBC2WA6mh)UTgMK6beQCMkxbx>a$uq-EQQk@?}U>IWxCe+y+px1vhxGy8fUV=0G
zF$Yyik0+I5lN^9iYeLUwUBQpoD%S-)aWj?FCcejDZMBSG%(a?CuyZjz2@gE6Q{xh`
zxN$j#JU)!&vppV1Q@-r+vVAm?rACUHby}^#xQoVHMCUkGE?m)@8wF9@fZT_2F*T}q
z#LrJ<MRrY1{ko93Hw`dRIK3E=W9sYUuFp$jQGW{!nOn+oe=CHRTK0+N<VDd(iSBJ~
zSlH+e6h5isZzDJj{a1PQE-$7xiyIpn>ODTAs{M$wjD*W$^fBrYZj-Em{(iye$I5%^
z`CC1%R=rG0{XUTufquqdjo<?l3XBeE*?r*(zB!%{=Q`>Z*3~rSxM(EjaxTO)kR9_q
zo_Y^ecT<~iP7l2)Q+cG>Ae9TlMtz-;cQge4VOR2>Q{NagIFWgRRoQx<Y(h~sQ7>eK
zja?UcjWiiE+ykRC^b@qqPG!~9A&HPMkRm<p`)7f@**=F|fA-3;xTB8BPK}(NafHzo
zt}qu<8E%fTtU=Akd1%n42eqO|DMnW=tUyXx4RiU*A0OEQ`nw>*hrcWb22GfNs7?&c
zMnes%tN)tpt6IQSFn5)sZl$cvX1bDUFShT{6x)zl-{ha%lpj{BF+X?as0a6a?3LCX
zi@mB*LrV3y#_%in87hMJnAV<Ti_6B%Szx05$)VhvjFyuN)DI{I3S6Mn%Mk(fFh&B(
zB|`bM(&%1#bt6v{mmW{D4L`j(1$zk&BcQMNo{{V|5&>WS2iUxVDkG&VRk~GSQOlo{
zPr=qiWgX^CN=pTdVor(+dUNQNL_YRdL?!>UPJlf+fu+_;EE+YSlfj_dobkfoRf&VM
zp;%tOsL|!=QBZizM)ihLrnxN^2Qdxw8rxks%XwC>ChRnTGRkH_jbo*#bO*{Rr%T|{
zREpU}riW4FIdP0dd~&D3o?POmEB{^4MY+R+6AzIBgE}>I2@n@M5b?kz6&9lmAl6FV
z#IU~U+T;Ow7pxD$td7fKr|{p3aT|eK@JC-oJrFHZfJ%h1N~38&de$KsIB|^CH}oj9
zD%0cA$b4#kuynDCo=k{JXD`pMd7TO^UZA(6X`ENKU)+W-X>g*m3FN-hUoNtP2c0ww
zGSsg2Z>V7#a8WnSmsFUIjS?ZxOpL&hf_1B1PGe^24qABd3Y6MLTKlW?%3CnXF%^ko
zuPGjaXOuw<>-4a9F;*?zh?n1IphXKBw3A;ve-*fS|M*L)7T57)jI+lS1F99|38P`z
zetM0ls>LH&t<=ik;??d3)y%4;aHI1LQp-bZasLa@=_zg1Sot%`u(ztdu?8b+jQZ&r
z4@R`Afmm24GEK2`Ip?mftjxih7UEmrcGaK|2hxIybdU6+G%#t<U54Hv-8aUMz21Uy
z^QSk$IF~ATvl?fCdca&?r?xicuXj~r!0t3=Wmv@N=~C%321}eF{^1Q@l{I>O3$gg`
z!Q)`HZcX8s=|a;wwwYJzX3DHeW&+hKwBt3e1D>xQ+3dN*DGP$x+K+2guE01|RZThV
zO80jSoGhxiuuNlGL)YNVoV+zGipe4-%E?ibm)H9zhyLvy#?Xi6(>(k!_f|aauXM;9
z#>9sngU}5tyJWSz-h7|rNNjeUv%H?NA<w;H1sck8dgx8rm?Ri0{uHf3mrqUp%-KdO
z)V<K6vcXvMGUg(cPPLfFqd$6p;l!qEBMm9q{_&~dg<7i+67gUQd_(TFE|Jqj%NaN^
zozrB@k~p1;=|PfQe2^=rOwigK50YWb9D|-qrJ==$;)!QHKek2LoFhMO^nWx+aZsfv
z(6!Lq6k{J_7Za9Fd0XGP708OogE><}Z~MFzk<>KBQi;kr0ty)#+-CAT*IkXxsd#i%
z=i_mee?@@uixxGN5km>xd$1A10ZV>v8j#_^rs^k*Ssn@}^#$mYFy&KW=GHj8UXvGe
zUjDQqW!~BBFLhjqOn2|EwV~-nk(2fDJU3sNJV<M5oxok~ZzNQl{h?AVRLNpA7nG0w
zbgB1HmCvD3uu&2?4}MhPe5{xfjn$16oMI|_{t(dZkgKT#^ctle#weEFY!B_v$8;2Z
z4`*4Rr#;7wnXLGWPe^qBhp3z*8gxUv#%fGmLUZ3-<NpU$w1X}uo@uKk46|LNL*O+Q
z9=V;{HS?TKAw!vSYRZ1)e7Dn?@Atg-;F&$)AyW;{&S-Rxr%Y1<&qjC*DQV2ku+te^
ziR4B+<6)y*!6;A`D0_lZ%kWDM=ni`EZg}n0Tkl>1D+;FG4e>K3y>f7EESF%Wf-MPL
z`6w2=L4mIV62+3<Uor|6MjQT-96bQz7R}&Ltty>zBbZ;G468||pQAprC)e|u{23n9
zz|e>b2DirST)rk_cA#y2fhPgTFSn47EiZOq3ge>fA|M@g(gbG6DAm-}VuHi(SII}h
zq_o2A@%l{5X2I>PoC_jr43Atiu{vfpY?cdM<~M&-Fe21U4-@iHlqnqQH)!-;$xGU_
zEkRZaUnw@v_!ic=l!BTd$(GKzFxf#XmhFGWNvU04UyltC^d^#VOJ07cBeKtF`p3+k
z(`2PPXnMkh4uda#KgyrZ$OHdVSaYm+{a&U*0UpvK1=J=7axf{Xgpl=cLA}Yv8+_-%
zZvKurm=1Ue=Kbne7LctZX1P?t<ybD0PrbBoyb|Q^%;nAmV-Z5G#8IZGYM~Yputq}*
z8@a3Sl3<W-V8Kf*b^MSDn=tLE?6LM1>OvlRE?tF$cy5JqMEi&0W8UAX;&N_dl^(1>
z1l>Cqf1?B#XN;JPMgn6pnTig)r|H9tnN}h27FaDF)6fWx7G-I_fqc*_X#Gcx4`>-C
zG$@o$3<raG6ugBV`Ai3s8a5$9efQ?G(#zo)kwuxO8|2m-q4?WVJlppn8GEj^W8sQR
zqp1_7U@67R9INp%V0~RvZGEGc2ww9FWSfjF-#t>>Sl*GV&v-L#m8*I+ng~_?(6A$T
ztc1uGfl8+Fz?UsRvw)t01aHLkv!u@xAgUKEWD<td3crrI4X8E-yyj5>#fR4s$s$sL
zPO2NgGaI@xGKepXMLlu|EbP&h8hCkGjiy0ZJ#%2GC3Jly({Dc{-kC;Vp)M-qPzQfB
zLY<5_g}N9K3~?!QtXFjgyMleI)bqu_4&g$NqhS?h_LQGB4wb*C86nRzX_crKl5+4I
zG=k<ZX?@0pz4^WDPe!rmp<@ggFshOj(7fm_u=1l;htx8Wu}VZ0m3j`|wdt>NM&*%>
zqinx0yO58-du`o%x>5^gSdk9~0u@EIsONH4tyfQr=TbM{I5kG-#~Z8h8n<^vV~r|c
zNE0*zwHOmFK*gjbRnseuG<d10k(pfS!uvQ#Z<Qow?<fqIh4pF~3BpaLe?3hu_o?E;
zPUSAlG4TR84F+fp!ruy<!_PVOO*M@B_)OD0C!`ElnjUi-8?nfj*FV*iS2WO8?!3Jd
zm(n5In_GiDl}^6G<KuE;Nbaw>yfzis4S))PUfWC0?(^4UOBBXcn61%E+SrDQ2F52!
z>m694^dYBEd;Gn1P)lUEnn|_D+nW=1r73e#Ne)lUo6JPeh4E~FCmeFS4?Xb4wuCgb
zS3E8BjWuk^mE(G2P^Hpct(f9d0O(odohldqLj)APdjHcK?wxqFi8){czXPFmxzOND
z%>?RJhHx&YpF&Tpg20{oWiDn&`yMu_nK6p7$*hSsS<b~9-L#lNX0bU#<YN1{#~)Ux
z@m>ro%4AgLqRZpYYk%QWd1@#a72NMmrA}PB3OjzV?~pobQI6_^Ju#-YwYmJ6HzjfW
z%TXfKUi56QX_3OeTp-t;j3G0<{-idh$RUh*WJ|_Hd0?xpx<j=rTP_RG650T2^2Ph4
z{C#fll~-QMoo?8W1N)}=m7Kp&30a5_Nf=)%P#e-QPoo~)+kj{CsE(#9*5=**{BD+!
z4O}XWgf-VET6PKElt$Y@Sl#Fn{b?99>M-_JhiG{hBW9dsRJaz%flY9#aFY<&U2q=p
z2?@m?m-C3n55>W#YZ%+8_5j5!P{(M6#!Ic3zxAS<3gm~sG7^o75v)s%bg!h$T#+fy
zA?<Z9_Cw6j)H*OY4J?gRu5);)`SSUzkKrb`Rg=wcZ+jx;^G&}ub;s(_0rq0~Uy9-V
z;ZE!`<bsZO;pBv@JW$R#HIzP&{|wI}(~v@L+Hk<Q+i!@<2(3FTsY6nlDu?P)sSeNv
zE}rq>F-73QAXTGfT*}W$V7j9G7}r6D3^K@|K^g|lk3y;D@&LOhNl#A9oZ%Tu+$sX0
z46T0$-Cp2YMo2EYWb@Dlr4~a?8G8s)ffAqV9~D0qxGl^iF(lRL$tC&crUa2ST~Whg
z>i79FsE4P3P!BOc3tDdOg(}3m1nBSi{R|#=7_0ZtrEOrsxK>Y-4BEe8Kk)Xw>4g`1
zOd8}{T`%<H*EZlC9K$Hxc(K>Ns7BGoT2Ng*mdd4~nPG!O7+ck_yw&Kb^IlSqK@{;S
ziiQQhJ_0wq2*XjDH?COK&@r3s&7|3!D)~*kX8`4)(1oC?@uDJ{Rl|*zX#6sEu`6ey
z(Rk7e0g%i+lYGo)>`KVRlLI_A^mmsl=}!Ic1tBsfuhgK(q%bSUP<nSWBIYl(KWIA0
z(PTD=4>3ty9UcO4gHC7K?}1Iet1&ZU7x}ImmQjr>ZkYIqAl)qLju*`WZS<An9oix7
z6(#lVI_~+i8&J$?FEoGgiAF{j)0Q{PpFH(m>{F%^M+J?HIIxeh219(K)N&;>XxhiY
z1oDGDl&^C5czDgLCZ-xj)&h>K8*t@1UF=oQh{zEQHooHH%%L{NC}sR8o6<!VHxAeQ
zSd4B>neaEdGN&DGdNOAsjVEd3h3o{>0$OqdfXSt2Sh5frrm#;!z6|HTkHFh({*jo9
zvx+699u|cBNgJ$28Oe%Rd^UF5nnxF*&o=)z?Hbn#pYYJ9IYj;Pt3-nuyZMXtT7HeE
zR=)bOT)q3{m3xS=S1R!GtKSDq@O$@0N5B@$QAR1{EtE#GQ^4pEMXjvV)u@a70+vU<
zl?7TZwA7(d7iuOV`)5qMkUpH8C@A#32`}#$64mCBgsMgk`MwTs!lsA$y#G7UJQ(-l
z5%Ol)s?+?8zoF+A0Ng1(^AEZ=BjjFoFV|v~P4$D^rZm(FjQHsrSzIQ)6l;Ep?+?f;
z{A=I1w;J=@o>u8pI&w^vj2dpxv`oe6%pLhE`N9F-;-tFc6|14BGMiGwxO;AJjCb%F
z>*#AqX<Q)d8x~7z_$ElBFOX~v$R#)gMw7Usz;1uOzaG2%9klOWVBe(bBLwB#df`I_
z<P`9KWXoSui&??Q3#5bbB+8#UJmKYZK$pg=at=A+#Bf3u5+pUO8_gFd3G$X6*0Z+;
zw|x8NBIC1flox0)knC>t0Ewc^x<UB>qdoWKn$uEE1PvQ%BPlEyGZ$kzLmLl!Z1_Z}
zm-{`H;Lm`bLGs-TCqGT2>6P3{XhhS<+yB$v*9OORo#&lhfWVRjm%xQ6QPu)lNuVW;
zDG1*LWQZ0>LLqBXqD4Zs8maUGyC63L0U8TRWMZYe0A1USnkpHmQIj-fW~^~MjT2`k
zKlnpQ-HzM3GfL~Eo++DAS~XQtx8qKd8U9ccC+YLN?>Xmw>|FqooF8q&kG=Pv&-c9N
z{XXZO3&LRdS_sE(4XpT0Q;YD8ZTpCfNxxt<*>V9CGMALKwxYkTWOStBu6nG?ljRRr
zdSwj`FQ-_e=jDi%<%b3Uo#o}7+i-GGSJ#{1);bS2HP^RSQ=;X(i89e`6*kohU}scC
zxJ?>OWH;A$6~ml!D=sbMT;R`QG9nX%kbH6&KnStpslVo`+jm2JEjvi1U$>wX(xb7H
z0e1I>B1{3<1$WlJeS$Slzi<}m(qo$M@#4+f$g^K63l|k5xm+gES#~Rfx+)1QM8+1r
z3x}lw2!46*Sn1Y>4IzhJRP&i?jXPd6`fFvTft2K`hY)p>Z1l?yTrwd~gmJ16EwaL6
zsBbhzx{wG5Ykwga@!;wjXbOUJ9wOD#Y;;O2k-5!ZR&m)9rY7(2>p?TzP+c=?Fq(jZ
z=v#lT@Y;&7AT^|@Lf58yCRe(9(TuKug@NKOk%THP1&BmGqC_GU{gbL#|44jmF+ZVJ
zf9QTS_h75J7|?=P;Z<xJj;Tp#pjF7<l0U-15r=Rd)uWgIUeX=2su2<^<*mre&M|+H
z){3`8*6^0DSq9MR3P$G1SYzNCcq=^ifJ3lW2q6fK^C<Zza;y@;#6h^>%mz{yY;~JV
z9ZbCO^q?B|_3~vTyp&d50!@mc4jgcaUhYHvWOU6@wiQ6{;PsaU=x;fbLfHKR-|?+3
z@IDki7D}4A?r4IitqOkzTNwZr89@UyPjD_@T3LM|)Z{S4<-`tKwmAcPOe!riF+pMM
zrnxTTuVQ63XGJ#AgqhX^Ig6zoU=@xpU#L5SC_7$Lz+tMZpsGrlQ-OhnwT_)SOHsPS
zBRa!WH!x;l(?WB`8MWh@GjL`|xpJwLh9!IELRja?$`wp3P7_oUv~~)<)RoeON?5|d
zajv?Cqh7pUny|JAB@i73r^WojySX(h1)*b-b))BH9<R(_xp0ATiLjWaVfOJFF=Uo@
zA)NMfWvO&k?jmTkR3rGpzBLf*S_Ese?qJ!leLI8*7&!Bzj3wpL(zP0RkS~hCys4d5
zK_6Cx7w#2#^hhM9MHycR6#_g|N7!us_{t@8qu7EM29BVQBprJM>Bu44R+i@=4C9%u
zvacHghM+j2raVE02cFc7MF|;B1Eh5O_(Z4GrqES$bIk0s2-Jh&X3JHu|IyWzm*j-Y
zu#ZFrv=Npnr;jY0mz^9~d6li5!_IzF$*2y4iEWVMi#kW<&z~Q{_q**>@Dvm|O9n^*
zDX23~pb|!neRU2&u@YQ<?gOv|PDhVi@V>W-{$?P@vE8i+^228O7{P5iu!FFUnqy}N
zrjJaXKflD+mTMFElKCdZ$MErQZOj?Y8vl<*3nIfy2u9A#6Cfo~aCTY-7v#7aYt5(%
zo(6(2aM7{RQ=JL$Fg`85Sw0Z3N$t^1bH|LL`zZ7wM*%^ns@6@<nJe>4*hb57_&knL
zhwQ>(%syEo9ic3mft6>ckvVqp*&P;h5=4X7iy-^-oNIk#HHdO&yMc8<!b_E>@QSjm
zbsD_E7SW4%!r`Hp=F253R4PV}JtoNkvj|W{3WGQBW;NdZk@F<b5&Fi;`x^aE7Xt;S
zV9O2iY}kZ~GXlJi&qtaSa3Sy&JJ#+H<Y+uFQq*>M&7wP@%J~=t1Sej<D6ip|qoC0j
zBJId?Gr^CM3zSMpMNxxCNq$<6NK#f6@}D}7xb4ElO4;we(Ft=5H;llSqK#ZE0W!Y$
z0Tdm>2EJwp#*x#+ha=7tz!nZQqlAVaSH$7;1SJ6xPO!ci?<1i;i7)CnNvLp!vQVER
z(y$4P2@?)~3~M$Nj-p~#t2J0mvVK#Oz@){Y70W8yCRJW+g|I2SE=K|rVu(ZtaY##y
z7J&%3LRhmG;*Cu0G^}Eeks7B8q)kb+RnKLd_MfaeZ>rm?47uM_83J!R{c^2zZFI!w
z5d|2&PNN94P}elg#$+>{luYd<7_c~C8&)ymY3eJdY8p^kl)9Y)0{N#UL-?g7kLv)v
z3Yao4uBMlqz{fPP(JHNxF??%tTX;Gg)ovml$P6%+YxJIuuB^Zk2Nl9_$63BG6S@5f
zn>-Mgq+D-x2E>u_`SS}->4q^}f6m#U6Kr7LX{(#r`4R5Ah{!mb6>T9>Gf{Z@$Ow8>
zXLUP$Lx{%vj!M)`dPcoL*t2*8SAT8M$f0wCcDE0RY54s4nzdk-&SMj~ywiB@BEx~$
zbGJn=QGlk8jGjNgM&&lmxD$2ak@55A!C%$I1-Z33C+*`RdOv&~hli9d4-et~()sg<
zLeNhbrZkK^f<Apo5T(B#i`<XLt4ySUZfzt#xlIVRx;Cw@n^q#%6?0Z9PLsxVn~-ZQ
z))b4hCG{?<5hE#jL|xhAoJb}1gxEoD;z(dG5Y#Q~ZhP=Y)asr-vUnaZz`A{)n1Uf{
zG_H6=PEtAYBj?X^VH_EZ%SIj(<*J+qzHLfC5{<aZ@iG$UO_tQ?uR~Fa9o>|rmb612
zy=T=nb`O*hn;t%mY9Bd;hafr=M+WQ`bUf08YiS2gZBO0|&nxCyH&ikUFKtsl4AY(y
zm*49qPbF$2ZjsGpaJvr(^qq7uXf?q8b5@5MD9#59{jX^(`$o?E&|(qHY3S#vd6*U4
z$mE?ckPqGn5;;0!W7=Amk`;TPX;-8lKfq$Jb*!MKrmL*d7PC7U5dj2rSlYm<<qsY6
zZl-WQLQXLAF5y!oN3r5iMNE=wb1;c9*jlBsY-4NihGTxn;qA>XBu0}qf+{GbaePu*
zP!+gsd2)(%cn)&3&26ZNWXqI8+iIDU=7i7mkuk_yhRQ_p+K{1{CX%A?)F_2P)bJG7
z;0`<dF?GRAGe~8Vth8Q@EDkb>zU>9o3|Pc2Ee&lC)0D?nx>L|cr1{WxkiBh`ICMP0
zS9xIigC^m7%#z};MGc1Ubj#BcNTs8uR^6h=*!BhtJ9*Qd#tq&$;snxefe4$&Dit^b
z^9C53SQ`ovOy)Q&es%-lu9({D0;(f&TIGriVkig{hCCmh)bJ!iF5n&ZtT;kA<`igw
z8wWIDc3Dm?Q1yf@{(vVu^FTS?9&XSK=m<59lAC|aT&tv|4ja-!LX1J9yR$M_b6j>h
zq!df@kw9gx^UwxM^dHX{NeB)v5g281>x^t+*kDVAta&mBifzR5wgnSJF>`umbtN*+
zZK#R}N^+3%I9+<$z0c0(O9p3Y!+(Ne2f<!5)106gxB96=u$oP)g>t#6@i9S7(g+yl
z)YL*fe?c{o<92Tj)Q-foIpj&AWGp+L2bvM}W*coD_f*6u@rAH)i18cy>@_s#AT<M+
zYeHvY7NL_}^doJJ@!TausnQ$A{2#dp%V@Q<jO7L{O`U`-w^m(*>H!m`R{~<wGsfNG
zz0<;&LhF%*Ym9CIhi%~AM^c4_e@GGP>WeE25xm`^WixO7HjdqI!q_mdC=$h*6GGxR
zaa-a<DaD~1&?i)~n<fVl430R&E+ZVOv<=q$U=6_4{a_7D(J3xhAaXufI}_Ve0QlbL
z2kdB@M$B*p`?H|!!suSpY>!~J6NeCRQbvXhgnLTH@Z$EyIHHQg?~)?#hV!0a$`MAO
z<YdEX=$hm1BnX=C@zV_m8pvhqLeQ~MRk2Nz-iILk!3OLQ%$<}f5nW)}&;qTotWiYu
za1JH*GuCR@gGzyoFdxpPT!jp$XB2-iSvz4V*xz!<rL7|NwkQ#8g7E~`nkXFbsZ}jf
z3XkGUc^^X0|FZjTYeqJNqLAA0ZjXSp2>5k#X4oCis|xJ|T~_3)$}sg~7KG?Nb>hVF
za;H;Af^L|3zDPquAB!cZU5YNg`c#+`5}rYV3sBqey`6{6vaP<}DvSqu->j8kM2K`5
zSI5%qGK(SO!1B5=0<y>csmk(&wTq!%b(Laj(k3FV91c3!LaajTa*W8!>)@Ldxm3EU
zV3~PacvEzY8d*efk{dh2o?4Vmq#<G8bv|&U+9UpG0G+P|coQHu3s(I7Y?i<$vt)}Z
zY|siet5sL96pW+Z!gE1uQa>^r+mt9fFku=eZBsT*y45p!0d5(Z-<dc@AmF})X4Dz%
z8aQ*McF|1Bi-56RB9<_9Q9$;SAe5GPftF=Jc3YOgfVM0H>9=K>354?y{Kis~ev!h)
z@FHKNL7<-VO2DYTS2TPQ8%xvcqBa-Nn`-itGt7deW8crzf^n~V)NPoccyZ?45(2Oy
zZffBsu9G#1?#F9KjCT>Yk*%^8s+eUB!-HX4%56j%S0iq!-#Ie9;J7W#3ZyrSh=~PD
z{NfRVt;O79<X<IsqwszO)^TKi1&1UA3ILqX;nOI7u+_ts#mX250Bx1jFqoEP5{x@m
z^-aO-i9OqO3?FVsKsA;>m3W@#ri<oohR5lFBwn8+l*5?fwB#10x9JTJr}#j_B?Uox
zwF^UjSctn-u?2*%NIr(;-ZV<Sw<-BR8(3N1*^E&MGlyV>%XT(jME7%Q%dQK|W8~0r
z)&nN|Y2&bqnFJd3NjQ)XDJd&3Wk@;1+hfN=1A4bg%FqsWjA?bq&K5ZfPQ#vD)VDP}
znR$yz2j|muR7}KVCF$xgokB;bZuOmIQ^=CvCiG=Vi7ba1aMfK>3i%EXMeDL&ii<xy
znk+=BOF}$65upztzA1l-`Aw<iNG)L3($6-R;b8cp226)Vf)4w*sr``=w$BAlE)JJ*
zbbyou!jh1T2+EsMr~DqjaN^?)a`{ynO)jmCOqvqHu`NntBBNmWR>s8igVFgk7I9=}
zK>U@OS_<e3se=SMn})N<lH8FY+%UrMU^1X17(<v#i;MzQE#7(Mphuw}Y2mt!!4$>T
zM-_e@wMg000t7meFTG0pDUxVZC@K0ntCUP(?NNSq2qM67f*leNqo$J7OTodIutlVd
z`U}LH?rLnp+Sn)&dop|nj!loHu*uj&i<sM33eSv9wJMx4*s+Buo5p;fu@q7mTWnoC
z1tsG$z$CGZi-g5~Hf}2AkjJrb5DV>(gFrX|VTlppDCj-BBY^E%_S0@&N($M4lQ+u-
zO?nzeQTNJcX-Os&#uJ1fUM%Gk=t@jg_j)PQ4hxHEV6K?~CV-b0z-6#lJQrXP(Z_M+
zQM*E7y-n{Rpe|S<_M#$t9U?P}p#W3ReJzsDEE$^a7vOSgscC27TXz!chuoT{ZLyej
z8h8ue_Htzb>p8mHir-t1eQ?Y>x>ELUV)F$)rbWzmzMvKcPr>bC{)@2&Or)$K+wuB^
zST3!cd!Gv@s3+jqb#=QKV)yLoqI7iQ?(~{91KsKbIV@bA7~KxIu(1iQTY8|O!dLP*
zU{1Ys8r>kQeNqnD6%q1Y*e4XNzPslzCJijgf`;76PU30qEw->TEEn!ClDYP;=jr4M
z0Vnn#F^3{1au_A`N0Rt-VzI+wO~`+oM7K#9`FaAkIdSBkg2{{sC?J_#5W=uo!a?)S
z?UviB>}0EN(hi1PFu3IhR^h<u>obF})$EHju|>DgHDb{v`-Q~?oVA0<#%8tsx48vN
zp%();06ReJ{?;cn&L6c^)qLBmWxMi?afUDK*|g270oD2v)V9j5RtEjLLv7G4Ci@$o
zw|S58R$%GGKH}T-ncw%-YGk@2(#O-0jUv1kI3q3k!>%^@=<oY%I_zcp!}fEyWuGo^
zG3ahwykc{5cclmY!1<b)OWm^9C`rn8ZVBl^!GxBQ*GTWPv1k|XtqJSIM;qYlP}^vP
zTPxxE4K_zZ+y{8yOCv7QZKr(;IU<`1*t~+Ecj1>Lw(QuCy0xJ5qAFC^wa9lqqX^qt
zI{C)9x7ABeO1<<`&NmxC*cRVueyPG=x9J3golN^d0vh$9-e<ecGaPg`(Ou}<8n&w_
zExb=CunoYygjpMmJa|LiOP}NLVz&iWq?Pn0f54zdoAWQM-~(;jpy*bhMw@&OG~KE>
z%Vg9wmDTM577Z@~i_ypT2^{;yM`m!~F*X1}THyxzVqq2Aw`giX3fuE^wS68WwDr*S
zTZNkqDGKfOW{1#hujJfXb!pJ9Ol}5)lnWK==8YR;?w&DMu;{sBX7DNsUev_9HYHpu
z#@u%qdyrS~{z?VcHG`McP+|d3c>53OtH#uS-c?>ir3Eu+j!6c-nVe{j#cN1?8r2ug
z5`ML_6|;=g)2M|PMa>zsvWowgkWUa;hb=Bk?kWIfEw*(QxvmvHvt0sp1@{V~IX#DZ
zB`o)|+&SbOGZ*p8p0GZQax3WPG-@oN%_@e;a_PO*jJeQyq{mT@NLn^!`CS0296U>c
z+$#FQq4(yhz;;>sV~Q&kf%@QSv_S;p`w_T%Ql1FkGM=A6J2=Myd27b(ok!bMK+Rq;
z8G9}vw=Cnq<Q-f^DqfjKOE?EZYA6&<lX%Zrz{^q<v^;1|q3n+$<<n-wn1_#{ZbfQW
zd=8;bYdM7+p0JfUKn^Qxz8PuNM2SxV_%%!!5rXae7#fFN5~QVde-^`ch$M&!a`<64
zun*EMp~iU@7!3)A)52*qJxZ`4jAoCHSBcBq_d_y<<Vc>uXh<NKu9YNtHDfMWn`{%u
z%rk(eVqO9pk+@&PlafXXHbzeZZgTpPlyWssf&`QiIHG02w;$!br%{%qsl=G<Jx(kx
zmwl(rmf5o??Kt9%&X(yV_M){w-ut5DeGUXlmNSne@kUYNm>^}`kDLQVaTGH$5|TUx
z#5JSBf*2u7Ik91OP~w@r6dCxAE%GQ_%!4W!*$)L$%Q5bL0wtDF=F`Tsp`EtNU{l5X
zig|%8?OhNGBJ<&>5RCFN`c8^Kvs-6MDCKVAhLjfX^%|feT{>p{B<{&SmF98}pTyWz
z(5Yx(>nvT88J`hOBXx^dIrw9yXg04=G>@T-*>^}vsu;YAdr93<G%p*|OZ7lXVqYr4
z%}&SB#4=|1+2mXv1@=M#r^+Kr6^=6F<%pLkH9>ek#?g|p$*oG)$8pbcPvVMw^yulb
z<Wtj8xkP6BZqg`~15O@CE|rO;KADR&h|IC%SRB4dUxZ=RYzg&nSmKz>%~PmJT0M&T
zOj#1B%7*Dmm$PV>ypQh)VMNVZT{+jh<Z`#Gwkh|b7#K9k6snc@{HDyqN1p^#gxaa!
zcrBHt$(B{=nfgC`uRs%kW?MriLbYOOPc&N|M`fbQ@{5DR(N=<}?mG%Zlf7~JFz%Xd
z6mvkQZCOZ+Y|mbm$;g^YOlGRtE;x>M$&l3f$$G41)y~5t-er&jOOlz?)@cFFj>{-#
z659SaYP(4>A8U=_X7WwJ$T79b784>TggA;15^;R`aR?TKNL<u@9Hk)I?uw^+283{V
z2x9dh1Sy&7rI0n7gb7EmiZV1os-O$1&MJgLTFO}vvl_lBqr5lFrC2<UR%#+T2qQ-D
z0PDtu4O<Dt1jciKkc25AhR&j{Gh$31=he{+8T=G-sW>RC%x>nYC^0=$<Iyph&$OP)
zI5c73YQ1j;c~~|DFMYJJ&jPECa%0wNPkh9{!Ik#|At@{r&8<d4o>>GmDNsJ50zb)N
z<VPw%;_*j?GcAwxX?eC7FC%lkiC5tIUJ|o`oScT=I0tB-uBM{{D6rAAax;K-75Jbr
za80}mdQ}wr0^3Jh<F^@$3E6glei13}DL_w*b55xSXU%7jLp%YhM_QFqbN2+w)nIOs
z^H|r^KbHil*~(>M)oZFxRIn=QlIcX$R!o$F%%{@&*iKv2OexlXePiokIp>2-#C^r2
z+p`@&QU-O*^{}1#Ee3MmY72xO7mg@Fdz6~gywBS~^Uu^@-wraWn74}{ub0rFyN}zQ
z>MOdu*5$S{+!S;T$9r@32t`;6<UHug%s>>BC7|HQpDJKc#4oJayVO#0{*zZ#eN+oc
z3VsrZWl6J;#M*nIQ5q0rdMXPQA;ca%FnTv+-=_eb>5F?UaUo!8NeG&GlPyL)@z4W(
zpR;hxwYZ)7E#~EURXLOs7l7Yu-UPshSS-9Bp!NDsZH<<vEJsu7sXnHg$SFwA;Xp_X
z8kJFFJ!w2Uu1X=@nRtE5`uJ4RDp9SK-oL4T@drPs?cg|NFrP>VaXYQGpocy5S8LAu
ze2_wkfwXX9;>faI>H(U9ts)<uhkI&hDKtNz0`FSHGtIqttJ?~Nr4RkR(9L$xl!Ek9
zde3pXB3*8$eHSuv;*lcM+|`UuwrB1sH_^UF?!kCoGhO?Ve;rKOYN%<lH3g+J4h@vK
z8e!moora*Zla6#hsK5Jz=gBxtIyaFNoHByB4>|&pkH+-WP^LsS5@*y%lExbFO0O4B
z%{_|YIv0oAVQBlfOoilO*A8QUtAJHSB=syKp~MPZ0Cl0w_DJj{5i9r>Bd$?DO?kLg
zZYxrY`hIB>^c2h`im~SYw$mb!l488}(kNh?)LHcJXs3T=Yg%*w(!HT0zYNXGXg!@$
zx;mPo*wwfsn|5=cxQ{z9(Lr!FQ~-qTu<J467FB=ny|h9T6?WV;Ha#3`blOcX-N#G#
zzvf434#Z7nwa;8!*oSiJKbu53QAZ@ST1krs`I~8CFtH5KTq5pMI(eV)1c#Hf9iOy#
z8^XQ_<|5AYU<rf~52iQA*q}gnGW3iizY!v)@p=I$B^7d#L5T=ys{_cWLKv-cqD+Ym
zb?d+MUeQNtY7P#bmd+PE9iMFiNhzAM9tDUJi}6vKaV-!D7aqrQp$wg3I@V<6_&^8~
z-Rr6h9-*X<B~#LScifajxEZE0#*6vrll+-p8^<I1QJcGIJ;kB27ShLPNu{^YJh2=n
z<p3putuJ9Q<(DYtp1^2z#Q^3(i|I~c*Bo3BvY@uPU`Ykvd%!4~R!&-!q|N5mwbcPP
zP5PH(B@wn_z;p^qON}#03;K}2R62gCv6|*qg1@cGyBTyLVe>Fo&q#MqVnn=>Rk`X%
zrc<34hBeKe%YsX_V@xM~z6*YKLac}3KsQ3s`B>8;-k8g=nw`WpS6R$(GE5ovc~1JM
zS-+Zf$%O_IUe__2S1L{c@@UAD-l(gmf+1`@S(dYu5Og1DU0eB!;Y<zpo1GL=wDVFz
zS|Qo6leF+uS{zWjh}Li_uz7VL1^B&mb;Df)<|7LLHm<IsZAbS5m_3|c%3wP8=H8MB
zF}F~s>gp_VnEnDLvuGYRN5IsXE#kLCZ#?!%vBvl$mseLM%o2};;b=O6VN)@RHI=Q~
zG52vYui8E+gd7%0_M)XqtqIHFHwt|;&6)C1EV}%Naq_V1Gu$W;jXJv;YCus`({<ny
zCEH!~;+m|=@J`b@!#*mKn$#i#TQRnK4K;~ZXvK$B$Ss?AWFp<XHhpX>bZ&`3E{Q5D
znLgr;OsHEL;%%7S6e-t41)BS|V)Eo_jt_$Ey@>Xy45&&WI6ApRj+Fu|il+$dot#%P
zyy+oqtm77F&4Kt>Tn~vcJrFOYYfXtVu#b~!#XQiQMtl$gX8@RcD6n;NN8D1wxO(E_
z!3cLyF`B)M<P+<hbCm1lxX8&$X(CMTS+zZJ_QMr45xh?&X__>aCV@zq?1R0!fT5$u
z2nE9>j2pPE+H)=y%_R-P(anq3rNP7SoEddtIgXWbWd^^xYBVpx-nnKGfjdj*FS<`_
z>o#!2FWRP%c20*mOexFxRpp|vrmIk5h{_S)VK6F9xuWFE4Yr_obIb7aXjSCnz30t&
zj3{mKUF1$L=TkS<uz#6n&;ylo#BGjH4^^w~Xrn}>I&~b*JKfA;dYwYzN+cnHYHAxq
z941`?G_UkJ9Bq>_4yeA`BBaq1mr$7dyGYR~UTD)=)tq2>3C7nfu*9`I-Pe~wrS~LP
zm1jkc5=-XpWS(E^e(*RTiOLMNtbPaS_8IiZ6)*GPtdt@han@S4cb8%$*{az|F2y&@
zu_KRdaK^YA=IDm_rZiCPtu$pul}1Q?QB!%-I&+TZoS_tAkRwaFI@_FQ*_)7rPe+>0
zHx5SgNZQD>rt)qa59Xt-%d7l!=6cFD)IFql$C0K-=he*^_!pifSKU;OTccD$xpcNT
zufi{-_&!LEFS%U9xK3P`4nocmzm(ig!ll*xv>7%AfvxCH%d~Ra>w)GhsY6<=|I_5u
zH?Q1;KvQ&45IrGcLXqK?AU7|in_AP<$yuPvsSP3{VOjt1529T%R*K*-!{7P*C;oKD
zS3dr=zifMF=3o8nsL6fyd!PG{zx9=CKe=;X&^VRtHNBb6eL?-}nO?)|Z{WIXU$EB3
zjNWWp(d0W#HXG!ETzfH-Eg&I>|CzRjkkPR(IFQX3x{79Ba4@s4=V3hDHI&Kj3%b$F
zzF;`BFBnG`{rKDUP^3^>M=*u|kF^^UO!4Qj9VU|r9&0lu-=1R{ejaPfp^suFC<Kjn
z+dG2wS2~I)wEoKeB6>KO3F^0l96R8zJOZ#R0L!B3ncdxhnkDelX)?iVP`|mOn9UUS
z?<)F?u3~#|Qi=qp3+xINPVVi_0Mv2x!NK*Le0Qd;A1Qpw2cKx`=r#DC=|p2hQhU+#
z8vbP3AL1Q;keBHT=7QN>z!2b@#X}ch_YZfPY|!`u{_P8%Me15xAy^95zpx9*1q`q+
zcz&nc7I3$_JL6M#={=LXOq-Nt<InGwhl1Sax`8CN(y2EE*DA0mZCRxB0Jc(F(72_@
zyAf1&72AlXTu<Y~ZoRGF#y#reH<-oG{iZEhNuH~HK^1>lByX~KkTx&z5y-BDo$Lj5
z^qcS*Gc}9<CosK@H*$dJGnj)LJ2=m?z^VS6kZ1g&;u}H(jW^(D*}_0Lis9$P4*Vd8
zgl3z;^9@P8k?qK}b@W^Ytr^pv<qvN;ZCSRvepQIrk$t`>v!XoESJ*Q|ib%~2X7fXw
zSeIGYOXBoT!R(%)Y^3g<p|;4=-dH!mY~nc=Yb&4ZD&HHePD%>ai+3f{EKjGUljmby
z_SCOqzC!Txg*)TTMVLG?W+me8OurC+mIz<Jy0b{B(G8Bm?BP!44Xg;RL0VSkPndQ$
zyRh86OPJ&e269N|d?2TyB^dBI^*3dLr2+(&l+CGZ2?jKw{w7H3Dy7r4OmKBKd%UXm
zB&n;Um8;o~{2{KisG6oBp#j-e`+UJ+ePplMU^chQD8#rI**M#sYwrN=+A|=jd%<<Y
zAgFx(I(RzHFO-CWU@$0igV}g~0m4QI1l1`K^6biqhhVn58ys4{t?l<``XO7}@!az=
z5DrooJm&5+JDSpvfVzqZ!lrcv60+yx1ZDjdKtl#!Ym21?xjP_s?3jGf9Avy3s7t&H
z;DxY-cXw#3eQwa}uYj0cqkRrj03g2~K!)|gyZqi_8>DsvlB1hbSx_<Xw#bBA{H@>i
zB&95Wi*$%oOB?kY&|gvy@_shkffk?)AbpCa0G&~w1bRzbeM?$>O9aPTAf*8z+N;3;
z$!CD%6Cua9LdyJ3czerI;#>Cm9ecfnZtCAwUih|v{cQpB+u4q+vc|WwRCSL_k@d$}
z1i$2{$4Ss2`vEp_+dky>An|}`K#05nCqZuqkl$JwWtA*C4A`)Kn^?$VAU!Y3D8Zek
zXWj6(@qNc_Ik};}^CMa>LNa6&{p7tHdn~KMig+ypsRzRJs-(LR$^BBMkdNgSfI;+*
zF*R=Em%ZZ`z1x|}$qjo~q^%cWkX*rV*pa(MtDG@Ry2ukY1%Q<6iHV)SOZ{_X7V2PP
zC}?yMJt{Etrv4^%exoaZZU}Nx<%_Jsa`k_JR;0}w3S}wCcFK@B1(+S;61Dnr1YrH~
zppV4SN8;!USpBEkLwpn<M^Or9N+P+J;w_QJc5=PMMKS|z=MKQE5w-x_4+V{BFioN$
znft-+OuI7ACZ$ZF&_NR+S2)<6)#95r3KT-lLDCTM4+-Kabsm~e+Sh4@JMG>y+c?e9
zYTlc5CrmJoCnhU`*)GabQseDBW*%m09=8z1jT6F4FlB_UPmr0AC}eh`9Y&@>3d~!B
z$%6>(?#*;OB+ne#En&UJtxgz?^*4GA^#_ev669TGhwvKugb?Y*Kjp2wX&2Q%^?;ik
zj5pljuimf_tz#zbHlPGZeKw)m1J(;T`lb+)TB(p*H_0FMn*?adqk2iiGY5PFO<BgS
z-{^5FrK|)I%t8eaT`-)NTv9MwC=jmtP27>dX_sb|zvZ@@v>3HUdxYGhDSJ^Z`rJ(_
zjV4eUf$MDJce$tf&!8^_h)S)?rNd&mnim%Eb@uzmM5R4GLuv_sgth!*vX;+aEe>0;
zS8S)a3Q^b#37Ek&?<r=1G-ncbqkPmvF5E#jPO9vj5!qLu+cDSK(I@(es9OJ4HkczW
z`U(_Q^#)mcPDCY=6_CcQ-Bj^XCYYo6n1h%J8aMm!zr6#*L~_K1_jCJ;J7}SwfSGF>
zuoui@UTzyV?=FH>(0Jo!I1ovgBU5m6BIy1xsHoA!6ik^s$k;tmp<5_K_;$Q-mLX|S
zf@$_i^vCy<f*@7v-w1EN8Q#7_LT-G|>c4N;>o@K79iSabm`W*6g`5xiMCSI02>vIT
zpeF|a*4y!qeEog=h_b>n+_*x|%YtlnvEI%q2eLgc6W1(`USaaT%w&Ncd|%i}O>{L_
z?-KPNT!o^-kaBKFEGt8CH{WzO@3eLF6$l!C0cW9Gby`S5I%Jtukv=)A8?K^AU$HX-
zBdu`*dI|%;Kx9Us5GYlO#oQ*jsLp<SURJquLoc^^K~r*ReBZ04oZhin3;KF-w~R{l
zr@yxf^hWy##Ni$zqEmocpN6GCLAsZ8O?s$f9@eLGC`6@a3-ywP;7UUEtwVXpxPby-
zQf?jI-f}nJaW}VsIT(VpTf=H#0pPs>-<(Dzr{Ha+kj8#XDQ^qa3M5Xq15y;XGcVO$
zAFvCN(dX0#Jx+kBCax&^va0Q?K^aWj!};npK~Jv}q>WcqY{IopNrQN`*46WLEJV(-
zf=`}}CEwk`rVVBvXpy7xQ?P@miwT~mTzDQq2e?g`lN=*694ZYQu>eKp0t4$siY)u2
z6CO_xV~nN+MW<Bg@p9FfScw!=5qe&~n(cuffO@FRc*sHg=DmE?#v+f}eNQ|EjqNlv
zm|ns3LmkQ8fO7>Ro<P4rXXr~DDJl(A@p{fa2ebEtj)}Tcw1%L~8n^n*{b_koY2I({
z?&ff$i^i+{(cAt_XC`~^rrAMmi~Q|OJjWJ71nTmD;ywht9~gv>sXiTU?+$Cx8nBgk
z`{1T9b2>GE=URZKAW^dgdy7$t6{hZ^>$E=$%|i>KP_!6tuBip`#TE_N>|l1Q7SKgH
z2o?f5<W!cyY)hs)fhJO2Ol<;6_CqZSpxstk(8u?+sHIWRYv2`tl#aea%Vz609&S-d
z3={E(F&I#_+!k7stqA4T{oHO{le+Uz(YYOvq;XDB<$CC$P3B%LL>tlQb1gyKdk03?
zl4SLvwA^uo4Er+(tTg*Ht|EMyLR!95MP^^i*?AT-<IPqIu|uIns*e!~hFmJp&ww$3
z7R0#7qP!D7^6j3>P@NdpEzvFwK0~u0*t7@OQIQGLJs*3@b%A4jUN6Q^K_t^fibS}G
z#t|HuY$nG*MUF9GDl~|=o$fZ@Eiq~&suc+L+$Z#*OJA_y3pz#Z3nHjozro<KG>#y+
z_F`cHl=>{Cj9AGCSQ^TPTh^bc-#}1WpQTfMK&YqNv@;oZwzWMzAyN=_pe=~IctIpY
z`^~w2VL%C{T)#P%V%(c50P2O8V0NcL>`1!D@FXp7lhCe9qH`q0b3F(Uvz}|b8xeGA
z0O3r3JBwS}Sa-kKtyMVGg1zTx3iNawb7rFtg}X7Ik-YG>AYuFU8+m(GLlrI?Mis1o
zx!-gU&e=R&cU;3*<ntT}7zJx4GKu|W2duh$eg{bs<xs2MKp5lo09p?hw>(4M!fa=P
z8BHNW$TNHtF5pmfS^BAemBFd{*Tn3qe~poq`mf6pl8qdR8-)ZL%IP&w_Ck^QJZ%Tg
zma`oCO|MU3nsREF_2|WW2ILqaSc(E&riacoQsH}x-CO^Q`VBLHFn-;bFTsrMU|=85
zPoJF`Htoh_@b~i%9sShj{&@25wEuMJ*S~Oe<mEs6wLOcM{^v)3_v`Qc=}(OQ^v`|g
z5C8n%=6?Lge{VYYso(w2pZw{L|MVLN2cG$7fAw2G@kjrrWB0`Gb&cNK_-~*8$zS{I
z7yshF9Q>m{czNJcKiT;1%A@!H{*Qg=;0xzF{`}9+?EcNQ?mzp=eMfHp!M}U){$Krm
z+nqn(Ht@!O==%5n<5$+(-}y(o{|J+iEvV0sum60;bf2y+tgh5n7T0h>B0r2gbZlmL
zXkz@)<10M;u7nRA_;c^@@xD2n-HBsW@qu%GJdGzw)-vW?e$U^+k<9qUkR}~JhtIeb
z@vpR8#Cgw^OPAM*Yb(V|_^fwPzE@EzK3KBf8F{ey(#6VhvAR}V=7*s1wM<l8esFED
ze&eqPxRaXzhm%41bv}NceH#$AcV+@I5f>Lbc7e<w9KjFjM74Eh@^BSEkNLvm88d26
zjSY{2I)_ia)&}uOgB5()TE4+mcA55=%g(XEA^tVyQ3T<`c{)>BT_mpXS@?S~S(C%V
zkIuZfQZ3Kn^M?51SNY6p^+lZ8$x&ca7Rj}zaX`J<=Lz!^?(_NJF`?PU!?}zhoq}9d
zcfbQVL@yW46k?1L|0kR5*u^9`*`Rr<ml<5a1PIN~1~YraTCo!9HiDusz@+|NqCin!
zl!#}nOm3Gg(A(K5F(C33f>`VCpjk5V`getqu`0a&J%6WZcqA~0j8PiEA;JPDHNb3N
zVP9uEWi?ZM#l8X?`7UKqrhOM6=^}VKOAs|8>U@Z$(6%d6*sVsUnD9Gy(L3bY$bnAi
z`><l9jBmaV5kBx&J`dkM1Em|x<a-*AVU<(F44q&VlXI#Q>aTYYo%KdXC#=MJ172b<
z!(ezYLqJUwP>8O!e9)N9)8R*@IS?0+JeLLeVQ5a2sfGr2=75sm5(G0OZO}Lw%wZK2
zi#ZtgFj@|<LV78`3zOmpWDq;l1#*iTAsyC)&<q-<xuS|b8=uGoRR#NX%s1!x^(-9Q
zm@s8Jm_bP9byT8Kd|lQ<8grN$)Wa1?7-jGY5>ew>OrJpdJo>4>z87mojS_BW*lkdS
zs}(ftDy}qFJ=1v?2xbmL<o`<m(87k=XpaA8!bAsXAFK)v-2nh%!xR4%c64S7eFcCv
zE#w9+INsCAK&Ye4KS5yx+*|?BpAPH>$?LYK(c403cgD$zl}LZPh;qFRNI?EUD6D%|
zBB9tR7J9st^v1?OZQyQ@0!#`SAjUE$obfK%ya;lFzEV1w%?crl3uVb$?spO(Oi$xo
zou<aSc5)i;_JWt-7dPHUrsAvd?hc3ph`3G;hOwRkxE#_125kXd3i^ce3y_D%D$tl@
z`=Ge`FYWEzq38sgzYApc5}A!lAczo`3?r<6A4vdb!|2sLOHs9P$>2LX(R8E?m>`LC
z)PS+TA<A8kqFnBkr}q-$k>@^#@JN~f)DM<JEGtW51PKYLeul(T%|XC6W_lV|5ONob
z(-JPSq-U7pjayQ_M44Ib?%aW2{3G3w7BL;L$s`4tK#6|}Hrg%o+(>3%5eRaor*Vz)
z{SsscWhPPI2rh{j$ty|lxs!8&D{O6I;uFA$&I#G?62w%m5-)k|Wxz!<I%qUN_m<-V
zVo+QgOYuSF4iy&h#IerZ<VB2$#v3IChlsyuw$VtdfubA$q|7Bd0C4h2kqAi2(YZkv
zm#|oNk~#-MY&O@44IM<h4v^(JKwdeXDoGCOGCD$NB3FNZlO`%*;W^iz*@0Ln7GqGi
z@fKuYd`RR5j03B+$e-npmV5(RlgsO(HLt;^$}9d+p280M3c#39Y2XopOW*<XY-Do*
zS6Mc?7&{b>$zoi=MmMR<@$xLk#ad_-0eLKs07zV<0Iq0u7n8B6L#x=n?`aw-rLiC+
zBTWK6X%g4$hrpET-9&$(yEnRk7_?5?Tal^102m{rSfLD`by6LMF!WZVLI#$M9R`m-
zgEoSVJK8(5+1!rKwp>p3UGy}53Fy;57|h0gp+BH1XuOWFJ1-E&ys($AlGhF3mpjru
z_Q6m-@Hw+vq=2>n!p~tdRA(k9c01b5!Zgou?E|w)G)fYD6mXf`($l5}ln3s->1lio
zEz2Vug=nqaoD7>~6|>e7E|=R~K$tC&+|8r{t$?8<NX%ux>xZC`*q_=RGOhx66`dj7
z8X@`samtt@B!}ei9+a*@w|;o+blP*BZT-0Ps}{bAQIRlj0tupfZ=y0nY#MY$t4OpD
z;vn%JiCjwedHNj9M))+Ajpt_}1F#l&6SQU93!AccC?##86fCw#&;DL}iaw%FZkOFC
z5`p|s6!JsRM43XbxtD4iD*=ZTfI~n76^$F<Au2~<<qGclGe=VVjJxRsjaa)HpOf=v
zvWvH~^K_+FD_y9ZEN4d^*da?kyE_@h!$y!`19}$=GTHjS&Y1c?pQ}}hYZog;d;q*s
zyda0?FBRP}{U`mmK8pA{0j&DcLIroVHGJo0uy_vD@JVia^nLNN`@BGL0dCcNrC7Oi
zWr>ILTL;R0ZwBY*79$PMUn{PaUSMLWSeDN^RF)U66<3zow*7D=JE>e<E3T{-Pr3us
z<<Rv(aOv?Fdhjs~IZk|L_%Pg#@YAxjvlmycES2Fho+!PD@9QnBtggaMJbPtvv3eCR
zOkfFzCKf304bVBfB8D@#F@p3+0ZWO5Kt66%z~so_5HPvjkc*aR8JpsE1KJbV+y!Br
z!~BQaO;`nO4XBN95X`1+aUT}j;+1_2?C->^vG-sAN*l6nz!s=~J~mqQhzG<Y9(~k*
z(&waps*WFtz!~Qp=hC%iFL>I1(2kBUKLu8~gzxZTx-4pzt{o~qaTVWUF8&C7=VE!K
zLbtbw&z-{=9_%!2xo(Kdc0@}G^`A?Dsz|8Dte<|SRIABnGmc)vS;9CU8NOi_etCpa
zhaX6B(?OV(HGBaDzWKGHe!*VIb-uJ9G*iQ;K`O<SMM;cMp#QS;;FVUOjSf8u;-7sH
zgRXt@B0$1dRPYJ0)hcMV8CiqQD;H)_nAR?q)`~BYtcv*JiDe{wGH`iqa5AOW`-zaD
z!|c_5-lM5sW3Y{;IppzPQ906t%EM&VbX2a)^E0Z&QjHu89$PGy^edEzoeYY${1>2O
z8UqiJO!<JT7!j82v1f>jVx(YhCkYycRs&1w)*#ZnG;oN`!J5crrGS(d1w6!-q&&M|
zap#kgm5?Tt5I}Tp+#WC;1-SN!5MQRy4GRT(h`JCyf+oi=l{(ksv$B;0CR*1XgO>dh
zSNfn^xzB`|bdBMU$eu8CH;~=wv!GHU1+%+hZn|1fFOe*)F7Ar9sE`k2DGCPqu-5@S
z)xT@8CyYJj#=yt`!LT|(lObFvwguURybjMjYHXttR3LPqco0?PUs3i~7?!__u7cdf
zFBml?3w05U5ePfG*M^;Apungf-2D(kZlKag{mraZh%R}T18|_=x~{+Jx~{)zYuSr9
zd;=fu6m&zZ>39X%!N#P=gv=_<Ot%dUla2XlbisxY$&6bO)wdxmHw!$CjJm+n6@Cs?
z!%k0BD@)~+px~oqk@NhjU=>;ppCbobLo%Y~;*}+6J!q%-D;F+^rdlo+%hl3_<rM@K
z7ixo`-uf3w?P_fPHUzsE(hc5eIN`UM4RX+Jax`2Agz~39o-upF(AgZ-b{_=A<k0Y=
z`21+K^3vS00PnPGLcw>fMm|*orxrAj(TkzQ5A&-RcIrb|n7jjzu^n>Ut)1uI0v{+~
zAZp`rF?M@X3S+-}uYJ!!Z9&(xR%6%jU}Jq03f5}0K&UnRxPVDXF(e@v^&Y(q8EhQy
zqIC(v0FfZ3$Nd$s%q1nqs3pZgeg_QRTpsbTJorDK@5{>`B5Zntzb+;!Yiyjr6rje&
zDSPF!_;0^MR}D-MG=3)s=Cf>tJ-3bDvBh`q3fp26Cm@Tsr4C#Iy!yR$`A*pGLF3D|
zgiPxh=<kD>JWPG8M`Xy3FbX%$S?uj=3P(}Qb&+8igX_asv^Y`PpGDtr($^2|5tI9z
zwK5R^`n2@*DMVkJqU2%|jEqs)gkM2SsyV#;moe=p5dg;>*zb%?eIyLB@f;j14TF3N
zcnc|o==ii^w80#GPK$7S3L_KAfO6QRU?Uv7k48Ac=P<$%rb%ZS;lOQKpj1lIdpfZ&
z)@5%#vT5DZ#HY@>h@G{Npe_~r!)dI!M|wfxUb#v+h!~fNa-_hUvW>%9bxcCw5W|qH
zu<%|GWBq32Io@!#iy;cvGF+^9uX$(<pBv=vm$)8KPkphm)YKV=1<1oqlJrU8X5(EF
zk=MB8U+d%H&ZVmILxMVaksRHt05bFg#XUe~41zS6-$f#iG(-d-fpIikpr-`f*<j<c
z5ak*Kpa+JV;(XOEOo4wO%Ub=3R=C?UtfdhP2YMEQBrKU_pprTWbwcedO>|ieEDxPf
z9f0Yo4Pzkfo=(szVMjFMv(~)}a)`S!L<os=nN(A6H`sCw-A4Rh$1@^pnBN8%0Cxx~
z@(wHt|66Xek^2JpI9R_CY<!^)7p}jE56mqkDCO@7*~Tk)SH=~Pt*21`QbHaCk*^B#
z2*4O<bn__uO??fjmmQuWXX!It1~dda%8nGlUU^7t_5?VREDQ3u{}LEkdZWE@189PK
z4c0d8SQX9Z>#wyEGZXLG^*9Y(3%ecab$La;s6zcp%NpN!slG@bWC;!f*W}98+T|6P
z*0mKBEw12u+^bbAez9g{fnM(FwZWcb_^+^wVM=j!ztjPWVsKvw4L8^l2IX6S9qS(8
zn!aEL?-8_R7$DvUu7lWkooqMbA^==N5F_&j2nY2VFyI<!@P@SS@~9Can^%Rxu!;4~
zP7s!e5j+Hq-w%|`5T51@egGVo7CL$PucUs&HUCf|k{X+pZLXLmUH3pEAL;BO5E8e9
z_4F(N#>z(n;Y<9Uj1)xRQlw(zrfAPut37A&b|OVZG#+b%^JrB9db}bM>-<=X8H6E)
zk{UN9Skqvzh7>6(csAd~h;id4R4_(GTi~^bgw}g8!<m6{IeAIP-s4$?Fm9wK3qVAm
zLtDa%2=~a^(Xw8IYum_D2-uFu*=S+N+1Mk8;XBH4$sPT2yv)F;Y3aL;Rm`}jtdrrs
zTb1Gdale`rzB(}!Z2SV|oW@`MhR`K|Rk{Rbd+GCo^K>gSE<h&mEGdABM2N{`4D<DX
zo&Z*nfH6%*$s)6{7A7+@hkHg+c@-&ggDt?X(p9dW#{U9iLmA+TB(cF74^l8{8GuJV
zn2FK2D=kYzx&s=G>P;st6Yv|hyhhAP^b7^o(b-1IK;zsO+k?lTCrhq?DUZ#^NS95>
z1Y*65juPLOSns0n{VcA*#+PLw1)fa(8;n7N1J}E_s3E(Y8G#2W%Dtd;z1^a8y*(>S
zAFwmp!%_{tt?MdCpX~re60$z0fn7t=W<wWpY2I)i+`?dk2{g%Gc>t@!Sc5`%M)FYv
z@BxjOEE}?Ez^+4E$JGUTr=zpIfaNGZq;Gn!=^Nf_`i7Qu7hmF=zQi}RguD0>@Awk$
z*#2C%+|+^>g2hlSQ1`62gA}2oAqq$#_1EE2yXg!zewnDjyP*8Nog)`ud^x$Hg$m`4
zqyxg{u5-Lg={(M&^t$dYK!8oahFdX&T<liX58VUH0CfoIhIg1<CIs4o%Vkp74nnVC
zI}*E<c4BvI2MJ+2lFKC02!pZHjz*^OXeoiWLJ7R-!1^}-fSmD!_Atj>Tm%ZS*;{F7
zTIA#UwD8=oKnuxGg8Eww>GsGP8R_^tf{ywvhr0S(4t4dnG|OFliSPIlwz9kU61RMb
zTef+7A*<<*^iDc^-^D(Aq#(?=KFyHA`m~mNyO48jHTJu<8v7;FUtEd$+pa|YZCl-5
zlvM;H#1L91RcLq8m!^_QAdl9k9VayQ6KU(Guq^;$0q?u<=?smruk+_OoOr~`0d&!V
z4aDXPojYN4L!HeA>q97mvT8I#z}|N5FF2BW*#Xza8<2XtcEJgYCPfxDq#)U~@wk*m
z3>Tv4IhoCGpn-L|JQPtq1nHYQDTd#o>2N27eZ+tL7W#+iQ_pY%YzpqF-wsVZZWQJV
zD$jd+k15j6oAUc@UHA!}m#VWU1`%Z+XmUS~m$^XG>{6D=2@hYV1f!uK7UF=tjayR9
zrfAYzNWxs$G?2No8L>3Y)s}>XNW*ciIhkJm&!C&II$C0NT9ULXS%>#$5bBAPYO1EC
z0J^dhil%iJX%IscjBrOA7#A0GxAC_1tG$(<Q+~vT9raIgT1s6RMJD>9NK>EsZR_P&
ztlK=iP7Yfs93(Nm@s90_Eq>SD6WetzSoz$$N%U;r{ra+6N+AJyWik@T+)HVPrnFFh
zM&Cq^0K)!oUID<vs@oyG*5Bkp#DF4l088fR2(E;_l24;={giH8B7NXN4F%rmlI!{@
znut_tMcZ(ZpnlJ_VDlXPK#Z*y6?v`*(L?`4&%_{b00xqp&HPD-HD5$H9|iDIy~Tr*
z|Jtsr<J;x?_jrp*+J)q1ySEeV$}9TO)=*Aci<I1W*Vf7-LX1Y-qY^Q^N+>v`Il1qk
zqnR)CVpilPmWAC-{WK{!D&FR33GoJq66Z<~#YISZV{U-4XMhOVLJ27f*7gbNk;pd~
zLaxZizFBT;k^cM5Ovc<D1`bd2`{DRsny)TZ*RFA`VSH#p!=KzAS*yXXI!3SR*vgg5
zONe4((ThUj`~1C5LD%@@P-IH{3{c@6eTfkZC27D$1!$xI;yWBPiel6vlptWa<jeXw
z)W^=ASc<EV<A|h!`mF*<m)&R4xYcX$3Uwmrbe(${m2_EvJrLO%&hT+e*8#K0(qsb#
zo)zvu6MA*!?m#&%wQ>&<;!@nP4+6NpKO`>PD>n);`6retL`oH6rTh~>AlHd3puoD0
zKq`W-z1gTJvKi5Cinck~+6*lR)C+hTO7QQnz?_5H6PRUvo}mWoR7syow(NJn_N$Ij
zQ>OMU;s-^Y_@P{&{(4<b`Ou(K9^2uVejV=tORQU{7G;RoLr6oYA094rrQ({!B!Gh=
z7940Xci-LFj-airNhgx6JVfe%NCT8|?>t!Y=Jg>v5ELY4X;1fs!yJlDgL`7VvB+eN
z#Y(v+mYR%|nv9ilPh6hT>0}hS4SU@R*wMh#Cg@w!zLu>(%GP+h00|5kfSGZ1f|fDi
z>(i0GrfpwQA$v%t!)1X+QAuO;ddF!(Lo)M1xx$PZV&@W<hKwQ%cpP&90TfFYvKBUR
zjC-8uw~~~q{0=H5Z*KqwTj2VM$N)~nkma5z6lB*Di5_n=a@hbjDrxG5aPxINR|(zu
zVjSBkStdxXM96q$jGC`XpG~ulhOkBbhe=_TGty)fAVYw_^C3VazH`7)1RRkU=YWwE
zV660Gt_MZRGcN7`u?bG#Ftp7RDV{|UeT7q$CgHmNoW&=pL{b6A^-o8T><ZZW@G63J
zn3#z&%Dt#-^(`c!Anm!3#=L$yB#s?tnIgFH&I2&p=o2mR7Y@VqvL)Ty?%G$V|NWG3
z;77Q`jeQr`uu(&pZk5aaP&G$OHTh0*ZKf9As1o0nKl$v+6>c8EE`uwV%UFiT{`_mj
z(&~J5Z544oY)p`CAcwFy1iSG01cg^wtqoE&W1M`8)SI5xwxukLdbZaus>k*!XL$+e
z*Q<+gt-qS3Ikf(&o2eztl-78SB`@0=myxVC=K5<|<26@<S-O3C{mZt<m$e9AM!~xz
zI3f#8F}_s55*B|E)Tw_p2IU$SuM1hkN(v~j$Hq4`)Es+~ceii&aOZW#PU>$E($88*
zKMQbFKl3iuN&RSS3U%wuAxz<6>@2dYM%R#92{+H2F0CzG#9IjXd^&bz;4C~!=*It6
zQHagAIPnZ*IS$w%6|tQZvb-Iy+H+SO6$stn8SWpiQbabMhotAVWUnXt_`XnZAFu%*
z2JDQWs^ww?i+HzNHX8he+@m9Ip}}A=>A2cw@{J|{3)hjMqvsv*a^2&DcTD+$FT*=c
zaX9;eE%S;m!#kFF#ka#dF<oAzYdDi<G;|i83AXA5*S{n=uPwzet=o1w$SkA7&3jEg
z<~Q=lVsmk|Qd%mWTfKG~@2A+EBiu`4!{^w6vbuIrqUV)GymzrSxC`o3oMIf?gFUme
z`D}p6__T^|G2Gyra`!a+BhjC-${Jk%h37No(BPA^=gy!NZXP=H47dy1KpuM$Z+aX8
zMJ!gADv#Og@aP0VzvGEjPzYdnf!m3eN<uJqu$7`~rg-+se66z9l`);8gCqLJ$cHoL
zzNafo6-b8S{FUkwHl8dOM}~$+A08fgczB`+3LL|m_8-ZZ4`U0`wbkl{i)+Py`Bf?6
z_NNuOFKo3se+8R>K#D=e?6Eu7iqa1(T-gMBFk=Q>27s6CE)N$kuB}~u^pQtOsEvJX
zgDb1BhzX)CDV4DWv=eWiRPg1I#`%nCJZm!t&sAz`wL`@-SLT<h3m>msdu(WEWNe6k
z#wO)5rB6dc6GJ1CVDraE#z)77N3juTNK5bz|0fTROpc9=Pfm_k7Dw?jG&VIdF+4v!
zIeB<;bmVY(u~b?dDo;#Ilq;pt`SQs8P-Sd!cyfMpbZTU(R3590FU~Jap_$6zO1U(;
zFg!9fTplS`#t%=83{8}$=Ep{+M#jb`O7n}0^Oec@%EZE9z&1ZRQ7#QFjE>GvPL5Va
z(OIRmcz9uQYO!2i9GR+2RM0o-O-@!Ohbxm4i=(BHk#hO){BUVxYGQtTacE+3esO+$
zXlQ=Ee0Xel2yjArj8+!MDkBS(!xJMTrOM(0$b4dIerR-LY<{6UI<&B`SeYs<OpXkV
zRmP?OMP<Sm?6}RzmfL<#+PUnVpIj|nesX2mzuk52;_Avv*#01Yg8%-jPxFRv1{IKY
zbD+)K>}WGjpFMu|Ta&-|jb9wRaQwB|o(mm+?_0mZDhrQ3cN|-@mR2rvm)mnsojv=U
zoy+I2MXvJP*_A7+3l*P+O;OKT@^oo~m&^0)@&DdG-#@^keDqKMhjCwYPw{Iv^P2vg
z2cC{EEz!|5mulD~Sg8z_mzJd5UmZYO-Az^gCgJ}P3_yEfB>S;FF+L!D#{e$?Hl?%N
z3H<-m<89_*gq$w6jUn|Ja~4M!KZC=VpT^xu9CiC7o=@WU3EcC~Z?^yOU-E_2tkKHu
z`Z3AHE3CNcTY)wKm*e=KL8~R4PRQ?o@Hl238_wgN`DZ|Cos+W*c_=eK9N>@nl@ecX
z{}vj}04APrs0VsCxAbKxGi2P~F?{g?I51-dYm;(9;w3pKoCiEZFZtuU^(f_{8O5=`
zBlyocOXh&D!y|?HT@`n{JVA<|6;`w#;rS7aj7Jpn;|WC^0nG!?FPlfrBlugghlRU?
zn|ahVR2%+GLcnG`W?G$qo9xp7&S<@7(Dy3FWe=A|yWx0rOp^u+xPo~-c%FxeFGWTb
zAJZUC59Yzh1|#?|>Yb94&sc-!qFn|)I1~DPPm_{XG+zY{MgZk7ASpIsEIhH2UnbFm
z)Cs>aj|-en+4ecx?A6V;I|4n4j}TtPiykLkM$4R$)^kVtARgo8lh|y=CF{%pULHEl
m?{D(Z`y!}3J`1cj<o{!EAM{VL4cNilLo@%)pa1_b@P7akzNn-C

diff --git a/dep/Autofac.3.2.0/lib/portable-win+net40+sl50+wp8/Autofac.dll b/dep/Autofac.3.2.0/lib/portable-win+net40+sl50+wp8/Autofac.dll
deleted file mode 100644
index a4cdaf101da51c7fda5a864bdcb782ed59b32eca..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 200704
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%0Dy!-XW7K6FMNgxAyq9vESpTr8Z3ZWa%JRBi$|
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

diff --git a/dep/Autofac.3.3.1/lib/net40/Autofac.dll b/dep/Autofac.3.3.1/lib/net40/Autofac.dll
new file mode 100644
index 0000000000000000000000000000000000000000..926f0b867f39fbcea92d87345c795c3112a42e3e
GIT binary patch
literal 201728
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

literal 0
HcmV?d00001

diff --git a/dep/Autofac.3.2.0/lib/portable-win+net40+sl50+wp8/Autofac.xml b/dep/Autofac.3.3.1/lib/net40/Autofac.xml
similarity index 99%
rename from dep/Autofac.3.2.0/lib/portable-win+net40+sl50+wp8/Autofac.xml
rename to dep/Autofac.3.3.1/lib/net40/Autofac.xml
index 420b7aa6d18..6cefdea820b 100644
--- a/dep/Autofac.3.2.0/lib/portable-win+net40+sl50+wp8/Autofac.xml
+++ b/dep/Autofac.3.3.1/lib/net40/Autofac.xml
@@ -2621,6 +2621,11 @@
               resource lookups using this strongly typed resource class.
             </summary>
         </member>
+        <member name="P:Autofac.Features.OpenGenerics.OpenGenericServiceBinderResources.ImplementorDoesntImplementService">
+            <summary>
+              Looks up a localized string similar to The type &apos;{0}&apos; does not implement the interface &apos;{1}&apos;..
+            </summary>
+        </member>
         <member name="P:Autofac.Features.OpenGenerics.OpenGenericServiceBinderResources.ImplementorMustBeOpenGenericTypeDefinition">
             <summary>
               Looks up a localized string similar to The implementation type &apos;{0}&apos; is not an open generic type definition..
@@ -4304,6 +4309,35 @@
             </summary>
             <value></value>
         </member>
+        <member name="T:Autofac.Features.Collections.CollectionRegistrationSource">
+            <summary>
+            Registration source providing implicit collection/list/enumerable support.
+            </summary>
+            <remarks>
+            <para>
+            This registration source provides enumerable support to allow resolving
+            the set of all registered services of a given type.
+            </para>
+            <para>
+            What may not be immediately apparent is that it also means any time there
+            are no items of a particular type registered, it will always return an
+            empty set rather than <see langword="null" /> or throwing an exception.
+            This is by design.
+            </para>
+            <para>
+            Consider the [possibly majority] use case where you're resolving a set
+            of message handlers or event handlers from the container. If there aren't
+            any handlers, you want an empty set - not <see langword="null" /> or
+            an exception. It's valid to have no handlers registered.
+            </para>
+            <para>
+            This implicit support means other areas (like MVC support or manual
+            property injection) must take care to only request enumerable values they
+            expect to get something back for. In other words, "Don't ask the container
+            for something you don't expect to resolve."
+            </para>
+            </remarks>
+        </member>
         <member name="M:Autofac.Features.Collections.CollectionRegistrationSource.RegistrationsFor(Autofac.Core.Service,System.Func{Autofac.Core.Service,System.Collections.Generic.IEnumerable{Autofac.Core.IComponentRegistration}})">
             <summary>
             Retrieve registrations for an unregistered service, to be used
@@ -6830,6 +6864,11 @@
               resource lookups using this strongly typed resource class.
             </summary>
         </member>
+        <member name="P:Autofac.Features.GeneratedFactories.GeneratedFactoryRegistrationSourceResources.DuplicateTypesInTypeMappedFuncParameterList">
+            <summary>
+              Looks up a localized string similar to Unable to generate a function to return type &apos;{0}&apos; with input parameter types [{1}]. The input parameter type list has duplicate types. Try registering a custom delegate type instead of using a generic Func relationship..
+            </summary>
+        </member>
         <member name="P:Autofac.Features.GeneratedFactories.GeneratedFactoryRegistrationSourceResources.GeneratedFactoryRegistrationSourceDescription">
             <summary>
               Looks up a localized string similar to Delegate Support (Func&lt;T&gt;and Custom Delegates).
diff --git a/dep/Autofac.3.3.1/lib/portable-win+net40+sl50+wp8/Autofac.dll b/dep/Autofac.3.3.1/lib/portable-win+net40+sl50+wp8/Autofac.dll
new file mode 100644
index 0000000000000000000000000000000000000000..926f0b867f39fbcea92d87345c795c3112a42e3e
GIT binary patch
literal 201728
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

literal 0
HcmV?d00001

diff --git a/dep/Autofac.3.2.0/lib/net40/Autofac.xml b/dep/Autofac.3.3.1/lib/portable-win+net40+sl50+wp8/Autofac.xml
similarity index 99%
rename from dep/Autofac.3.2.0/lib/net40/Autofac.xml
rename to dep/Autofac.3.3.1/lib/portable-win+net40+sl50+wp8/Autofac.xml
index 420b7aa6d18..6cefdea820b 100644
--- a/dep/Autofac.3.2.0/lib/net40/Autofac.xml
+++ b/dep/Autofac.3.3.1/lib/portable-win+net40+sl50+wp8/Autofac.xml
@@ -2621,6 +2621,11 @@
               resource lookups using this strongly typed resource class.
             </summary>
         </member>
+        <member name="P:Autofac.Features.OpenGenerics.OpenGenericServiceBinderResources.ImplementorDoesntImplementService">
+            <summary>
+              Looks up a localized string similar to The type &apos;{0}&apos; does not implement the interface &apos;{1}&apos;..
+            </summary>
+        </member>
         <member name="P:Autofac.Features.OpenGenerics.OpenGenericServiceBinderResources.ImplementorMustBeOpenGenericTypeDefinition">
             <summary>
               Looks up a localized string similar to The implementation type &apos;{0}&apos; is not an open generic type definition..
@@ -4304,6 +4309,35 @@
             </summary>
             <value></value>
         </member>
+        <member name="T:Autofac.Features.Collections.CollectionRegistrationSource">
+            <summary>
+            Registration source providing implicit collection/list/enumerable support.
+            </summary>
+            <remarks>
+            <para>
+            This registration source provides enumerable support to allow resolving
+            the set of all registered services of a given type.
+            </para>
+            <para>
+            What may not be immediately apparent is that it also means any time there
+            are no items of a particular type registered, it will always return an
+            empty set rather than <see langword="null" /> or throwing an exception.
+            This is by design.
+            </para>
+            <para>
+            Consider the [possibly majority] use case where you're resolving a set
+            of message handlers or event handlers from the container. If there aren't
+            any handlers, you want an empty set - not <see langword="null" /> or
+            an exception. It's valid to have no handlers registered.
+            </para>
+            <para>
+            This implicit support means other areas (like MVC support or manual
+            property injection) must take care to only request enumerable values they
+            expect to get something back for. In other words, "Don't ask the container
+            for something you don't expect to resolve."
+            </para>
+            </remarks>
+        </member>
         <member name="M:Autofac.Features.Collections.CollectionRegistrationSource.RegistrationsFor(Autofac.Core.Service,System.Func{Autofac.Core.Service,System.Collections.Generic.IEnumerable{Autofac.Core.IComponentRegistration}})">
             <summary>
             Retrieve registrations for an unregistered service, to be used
@@ -6830,6 +6864,11 @@
               resource lookups using this strongly typed resource class.
             </summary>
         </member>
+        <member name="P:Autofac.Features.GeneratedFactories.GeneratedFactoryRegistrationSourceResources.DuplicateTypesInTypeMappedFuncParameterList">
+            <summary>
+              Looks up a localized string similar to Unable to generate a function to return type &apos;{0}&apos; with input parameter types [{1}]. The input parameter type list has duplicate types. Try registering a custom delegate type instead of using a generic Func relationship..
+            </summary>
+        </member>
         <member name="P:Autofac.Features.GeneratedFactories.GeneratedFactoryRegistrationSourceResources.GeneratedFactoryRegistrationSourceDescription">
             <summary>
               Looks up a localized string similar to Delegate Support (Func&lt;T&gt;and Custom Delegates).
diff --git a/dep/Autofac.Extras.FakeItEasy.3.0.1/lib/net40/Autofac.Extras.FakeItEasy.dll b/dep/Autofac.Extras.FakeItEasy.3.0.2/lib/net40/Autofac.Extras.FakeItEasy.dll
similarity index 92%
rename from dep/Autofac.Extras.FakeItEasy.3.0.1/lib/net40/Autofac.Extras.FakeItEasy.dll
rename to dep/Autofac.Extras.FakeItEasy.3.0.2/lib/net40/Autofac.Extras.FakeItEasy.dll
index 1ee19ad5e413f193f07b5e4628051411746cb30f..6b9058ce0298ceef47f5e73721b80a61de1de7e1 100644
GIT binary patch
delta 313
zcmZpOX^5H7!F;L4WMa23^W-HA8*i5~)>qX#Z~W*v<$7N3hkJs7i!bG0D(~yK^kC;5
zkAiQnJi5<bPlyrd_-fTUx9E<GQUAW$dL;>mCGjtXohseC!UF<UGPTdVA+)cl>&wCV
zn7ZPL`#-e(O0qk0=56%r3G9EC>Ki!k;0c^#*uCfAg<U(>+HH#Z&gJhfaqWQ{=j+Zm
zmx51>t2bX@D&b*d-t5Zn&MV;W(|%WR$vmgFetzW}UAyWx&ygu-Wi*;BqNK=SWUgRn
zX=Q9U*;Xk4DAcF4$R6mIU<M#y0%93P1_lpDAXa8z2nu!yeh?*e?ThzU|DEcVx{>7{
zT!GRIDONEhsksF)CAkGg7B0@4^Ofb9IYFA4L5578uJ#dVaHslbMx)KO8j~4;l%Upo
FW&j&ud_@2N

delta 313
zcmZpOX^5H7!K^PMF|pg1c|8l`#@nTg^*o`+brmjUtmromU9!gEhWwV^J#otur&tBu
zP^_D9{wU9vFD}0~<~|7gQgK8mjA_D-y5g(%P4X5knX4$W(a|U9(cOv1bSD2SnL6!3
z)vH+oQL@SFJlbAnvweTzad4xbdPCve-$Igge4<6SH~5+NNmagi_;63j-=lh3KR0OB
zrq-Qd6x)1(sf34-VY4g0JFh^dHe0#$HATN2>$YFgeJjPYd5%muE2H6L5hX<q12Y8!
zGb>Zm$+k)XK%qXRMfO0y1Tz2u6A;TVGB9{J0<kg!Lr}0waKNJg<(`OLK2rqF?Y+6O
z{y$KfA;l`DBsI4nrX;t()zZ*)bH1`XGbc!b8HgDtPgna0G`Lg!Go#_=T8+t!KuS>S
GJu?6gH+Mq-

diff --git a/dep/Autofac.Extras.FakeItEasy.3.0.1/lib/net40/Autofac.Extras.FakeItEasy.xml b/dep/Autofac.Extras.FakeItEasy.3.0.2/lib/net40/Autofac.Extras.FakeItEasy.xml
similarity index 100%
rename from dep/Autofac.Extras.FakeItEasy.3.0.1/lib/net40/Autofac.Extras.FakeItEasy.xml
rename to dep/Autofac.Extras.FakeItEasy.3.0.2/lib/net40/Autofac.Extras.FakeItEasy.xml
diff --git a/dep/FakeItEasy.1.15.0/lib/net35/FakeItEasy.dll b/dep/FakeItEasy.1.15.0/lib/net35/FakeItEasy.dll
deleted file mode 100644
index bf603e6aed943d90af255ab2fc012f4a7e28e9ed..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 645120
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%0DB
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

diff --git a/dep/FakeItEasy.1.15.0/lib/net35/FakeItEasy.xml b/dep/FakeItEasy.1.15.0/lib/net35/FakeItEasy.xml
deleted file mode 100644
index 54ea9aca845..00000000000
--- a/dep/FakeItEasy.1.15.0/lib/net35/FakeItEasy.xml
+++ /dev/null
@@ -1,3540 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>FakeItEasy</name>
-    </assembly>
-    <members>
-        <member name="T:FakeItEasy.A">
-            <summary>
-            Provides methods for generating fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.A.Fake``1">
-            <summary>
-            Creates a fake object of the type T.
-            </summary>
-            <typeparam name="T">The type of fake object to create.</typeparam>
-            <returns>A fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.Fake``1(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{``0}})">
-            <summary>
-            Creates a fake object of the type T.
-            </summary>
-            <typeparam name="T">The type of fake object to create.</typeparam>
-            <param name="options">A lambda where options for the built fake object can be specified.</param>
-            <returns>A fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.CollectionOfFake``1(System.Int32)">
-            <summary>
-            Creates a collection of fakes of the specified type.
-            </summary>
-            <typeparam name="T">The type of fakes to create.</typeparam>
-            <param name="numberOfFakes">The number of fakes in the collection.</param>
-            <returns>A collection of fake objects of the specified type.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.Dummy``1">
-            <summary>
-            Gets a dummy object of the specified type. The value of a dummy object
-            should be irrelevant. Dummy objects should not be configured.
-            </summary>
-            <typeparam name="T">The type of dummy to return.</typeparam>
-            <returns>A dummy object of the specified type.</returns>
-            <exception cref="T:System.ArgumentException">Dummies of the specified type can not be created.</exception>
-        </member>
-        <member name="M:FakeItEasy.A.Equals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are equal.
-            </summary>
-            <param name="objA">The first object to compare.</param>
-            <param name="objB">The second object to compare.</param>
-            <returns>True if the two objects are equal.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.ReferenceEquals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are the same reference.
-            </summary>
-            <param name="objA">The object A.</param>
-            <param name="objB">The object B.</param>
-            <returns>True if the objects are the same reference.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.CallTo(System.Linq.Expressions.Expression{System.Action})">
-            <summary>
-            Configures a call to a faked object.
-            </summary>
-            <param name="callSpecification">An expression where the configured member is called.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.CallTo(System.Object)">
-            <summary>
-            Gets a configuration object allowing for further configuration of
-            any call to the specified faked object.
-            </summary>
-            <param name="fake">
-            The fake to configure.
-            </param>
-            <returns>
-            A configuration object.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.A.CallTo``1(System.Linq.Expressions.Expression{System.Func{``0}})">
-            <summary>
-            Configures a call to a faked object.
-            </summary>
-            <typeparam name="T">The type of member on the faked object to configure.</typeparam>
-            <param name="callSpecification">An expression where the configured member is called.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.A`1">
-            <summary>
-            Provides an API entry point for constraining arguments of fake object calls.
-            </summary>
-            <typeparam name="T">The type of argument to validate.</typeparam>
-        </member>
-        <member name="P:FakeItEasy.A`1.That">
-            <summary>
-            Gets an argument constraint object that will be used to constrain a method call argument.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.A`1._">
-            <summary>
-            Gets a constraint that considers any value of an argument as valid.
-            </summary>
-            <remarks>This is a shortcut for the "Ignored"-property.</remarks>
-        </member>
-        <member name="P:FakeItEasy.A`1.Ignored">
-            <summary>
-            Gets a constraint that considers any value of an argument as valid.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Any">
-            <summary>
-            Provides configuration for any (not a specific) call on a faked object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Any.CallTo(System.Object)">
-            <summary>
-            Gets a configuration object allowing for further configuration of
-            any call to the specified faked object.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Any.Equals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are equal.
-            </summary>
-            <param name="objA">The first object to compare.</param>
-            <param name="objB">The second object to compare.</param>
-            <returns>True if the two objects are equal.</returns>
-        </member>
-        <member name="M:FakeItEasy.Any.ReferenceEquals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are the same reference.
-            </summary>
-            <param name="objA">The object A.</param>
-            <param name="objB">The object B.</param>
-            <returns>True if the objects are the same reference.</returns>
-        </member>
-        <member name="T:FakeItEasy.ArgumentCollection">
-            <summary>
-              A collection of method arguments.
-            </summary>
-        </member>
-        <member name="F:FakeItEasy.ArgumentCollection.arguments">
-            <summary>
-              The arguments this collection contains.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.#ctor(System.Object[],System.Collections.Generic.IEnumerable{System.String})">
-            <summary>
-              Initializes a new instance of the <see cref="T:FakeItEasy.ArgumentCollection"/> class.
-            </summary>
-            <param name="arguments">The arguments.</param>
-            <param name="argumentNames">The argument names.</param>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.#ctor(System.Object[],System.Reflection.MethodInfo)">
-            <summary>
-              Initializes a new instance of the <see cref="T:FakeItEasy.ArgumentCollection"/> class.
-            </summary>
-            <param name="arguments">The arguments.</param>
-            <param name="method">The method.</param>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.GetEnumerator">
-            <summary>
-              Returns an enumerator that iterates through the collection or arguments.
-            </summary>
-            <returns>
-              A <see cref = "T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.Get``1(System.Int32)">
-            <summary>
-              Gets the argument at the specified index.
-            </summary>
-            <typeparam name = "T">The type of the argument to get.</typeparam>
-            <param name = "index">The index of the argument.</param>
-            <returns>The argument at the specified index.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.Get``1(System.String)">
-            <summary>
-              Gets the argument with the specified name.
-            </summary>
-            <typeparam name = "T">The type of the argument to get.</typeparam>
-            <param name = "argumentName">The name of the argument.</param>
-            <returns>The argument with the specified name.</returns>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.Empty">
-            <summary>
-              Gets an empty ArgumentList.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.Count">
-            <summary>
-              Gets the number of arguments in the list.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.ArgumentNames">
-            <summary>
-              Gets the names of the arguments in the list.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.Item(System.Int32)">
-            <summary>
-              Gets the argument at the specified index.
-            </summary>
-            <param name = "argumentIndex">The index of the argument to get.</param>
-            <returns>The argument at the specified index.</returns>
-        </member>
-        <member name="T:FakeItEasy.ArgumentConstraintExtensions">
-            <summary>
-            Provides validation extensions for <see cref="T:FakeItEasy.IArgumentConstraintManager`1"/>.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsNull``1(FakeItEasy.IArgumentConstraintManager{``0})">
-            <summary>
-            Constrains an argument so that it must be null (Nothing in VB).
-            </summary>
-            <typeparam name="T">The type of the argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Contains(FakeItEasy.IArgumentConstraintManager{System.String},System.String)">
-            <summary>
-            Constrains the string argument to contain the specified text.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The string the argument string should contain.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Contains``1(FakeItEasy.IArgumentConstraintManager{``0},System.Object)">
-            <summary>
-            Constrains the sequence so that it must contain the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the collection should contain.</param>
-            <typeparam name="T">The type of sequence.</typeparam>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.StartsWith(FakeItEasy.IArgumentConstraintManager{System.String},System.String)">
-            <summary>
-            Constrains the string so that it must start with the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the string should start with.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.EndsWith(FakeItEasy.IArgumentConstraintManager{System.String},System.String)">
-            <summary>
-            Constrains the string so that it must end with the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the string should end with.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsNullOrEmpty(FakeItEasy.IArgumentConstraintManager{System.String})">
-            <summary>
-            Constrains the string so that it must be null or empty.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsGreaterThan``1(FakeItEasy.IArgumentConstraintManager{``0},``0)">
-            <summary>
-            Constrains argument value so that it must be greater than the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the string should start with.</param>
-            <typeparam name="T">The type of argument to constrain.</typeparam>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsSameSequenceAs``1(FakeItEasy.IArgumentConstraintManager{``0},System.Collections.IEnumerable)">
-            <summary>
-            The tested argument collection should contain the same elements as the
-            as the specified collection.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The sequence to test against.</param>
-            <typeparam name="T">The type of argument to constrain.</typeparam>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsEmpty``1(FakeItEasy.IArgumentConstraintManager{``0})">
-            <summary>
-            Tests that the IEnumerable contains no items.
-            </summary>
-            <typeparam name="T">The type of argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsEqualTo``1(FakeItEasy.IArgumentConstraintManager{``0},``0)">
-            <summary>
-            Tests that the passed in argument is equal to the specified value.
-            </summary>
-            <typeparam name="T">The type of the argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value to compare to.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsSameAs``1(FakeItEasy.IArgumentConstraintManager{``0},``0)">
-            <summary>
-            Tests that the passed in argument is the same instance (reference) as the specified value.
-            </summary>
-            <typeparam name="T">The type of the argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The reference to compare to.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsInstanceOf``1(FakeItEasy.IArgumentConstraintManager{``0},System.Type)">
-            <summary>
-            Constrains the argument to be of the specified type.
-            </summary>
-            <typeparam name="T">The type of argument in the method signature.</typeparam>
-            <param name="manager">The constraint manager.</param>
-            <param name="type">The type to constrain the argument with.</param>
-            <returns>A dummy value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Matches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Func{``0,System.Boolean},System.String)">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="scope">
-            The constraint manager.
-            </param>
-            <param name="predicate">
-            The predicate that should constrain the argument.
-            </param>
-            <param name="description">
-            A human readable description of the constraint.
-            </param>
-            <typeparam name="T">
-            The type of argument in the method signature.
-            </typeparam>
-            <returns>
-            A dummy argument value.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Matches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Func{``0,System.Boolean},System.String,System.Object[])">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="manager">
-            The constraint manager.
-            </param>
-            <param name="predicate">
-            The predicate that should constrain the argument.
-            </param>
-            <param name="descriptionFormat">
-            A human readable description of the constraint format string.
-            </param>
-            <param name="args">
-            Arguments for the format string.
-            </param>
-            <typeparam name="T">
-            The type of argument in the method signature.
-            </typeparam>
-            <returns>
-            A dummy argument value.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Matches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="scope">
-            The constraint manager.
-            </param>
-            <param name="predicate">
-            The predicate that should constrain the argument.
-            </param>
-            <typeparam name="T">
-            The type of argument in the method signature.
-            </typeparam>
-            <returns>
-            A dummy argument value.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.NullCheckedMatches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Func{``0,System.Boolean},System.Action{FakeItEasy.IOutputWriter})">
-            <summary>
-            Constrains the argument to be not null (Nothing in VB) and to match
-            the specified predicate.
-            </summary>
-            <typeparam name="T">The type of the argument to constrain.</typeparam>
-            <param name="manager">The constraint manager.</param>
-            <param name="predicate">The predicate that constrains non null values.</param>
-            <param name="descriptionWriter">An action that writes a description of the constraint
-            to the output.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="T:FakeItEasy.ArgumentValueFormatter`1">
-            <summary>
-            Provides string formatting for arguments of type T when written in call lists.
-            </summary>
-            <typeparam name="T">The type of the arguments which will be formatted by this instance.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.IArgumentValueFormatter">
-            <summary>
-            Provides string formatting for arguments when written in 
-            call lists.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IArgumentValueFormatter.GetArgumentValueAsString(System.Object)">
-            <summary>
-            Gets a string representing the specified argument value.
-            </summary>
-            <param name="argumentValue">The argument value to get as a string.</param>
-            <returns>A string representation of the value.</returns>
-        </member>
-        <member name="P:FakeItEasy.IArgumentValueFormatter.ForType">
-            <summary>
-            Gets the type of arguments this formatter works on.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.IArgumentValueFormatter.Priority">
-            <summary>
-            Gets the priority of the formatter, when two formatters are
-            registered for the same type the one with the highest
-            priority is used.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ArgumentValueFormatter`1.GetArgumentValueAsString(System.Object)">
-            <summary>
-            Gets a string representing the specified argument value.
-            </summary>
-            <param name="argumentValue">The argument value to get as a string.</param>
-            <returns>A string representation of the value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentValueFormatter`1.GetStringValue(`0)">
-            <summary>
-            Gets a string representing the specified argument value.
-            </summary>
-            <param name="argumentValue">The argument value to get as a string.</param>
-            <returns>A string representation of the value.</returns>
-        </member>
-        <member name="P:FakeItEasy.ArgumentValueFormatter`1.ForType">
-            <summary>
-            Gets the type of arguments this formatter works on.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentValueFormatter`1.Priority">
-            <summary>
-            Gets the priority of the formatter, when two formatters are
-            registered for the same type the one with the highest
-            priority is used.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.CommonExtensions">
-            <summary>
-            Provides extension methods for the common uses.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.FormatInvariant(System.String,System.Object[])">
-            <summary>
-            Replaces the format item in a specified System.String with the text equivalent
-            of the value of a corresponding System.Object instance in a specified array using
-            invariant culture as <see cref="T:System.IFormatProvider"/>.
-            </summary>
-            <param name="format">A composite format string.</param>
-            <param name="arguments">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
-            <returns>The formatted string.</returns>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.Zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
-            <summary>
-            Gets an enumerable of tuples where the first value of each tuple is a value
-            from the first collection and the second value of each tuple is the value at the same position
-            from the second collection.
-            </summary>
-            <typeparam name="TFirst">The type of values in the first collection.</typeparam>
-            <typeparam name="TSecond">The type of values in the second collection.</typeparam>
-            <param name="firstCollection">The first of the collections to combine.</param>
-            <param name="secondCollection">The second of the collections to combine.</param>
-            <returns>An enumerable of tuples.</returns>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.ToCollectionString``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.String},System.String)">
-            <summary>
-            Joins the collection to a string.
-            </summary>
-            <typeparam name="T">The type of items in the collection.</typeparam>
-            <param name="items">The items to join.</param>
-            <param name="stringConverter">A function that converts from an item to a string value.</param>
-            <param name="separator">Separator to insert between each item.</param>
-            <returns>A string representation of the collection.</returns>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.FirstFromEachKey``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
-            <summary>
-            Gets a dictionary containing the first element from the sequence that has a key specified by the key selector.
-            </summary>
-            <typeparam name="T">The type of items in the sequence.</typeparam>
-            <typeparam name="TKey">The type of the key.</typeparam>
-            <param name="sequence">The sequence.</param>
-            <param name="keySelector">The key selector.</param>
-            <returns>A dictionary.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.BuildableCallRule">
-            <summary>
-            Provides the base for rules that can be built using the FakeConfiguration.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCallRuleWithDescription">
-            <summary>
-            Represents a call rule that has a description of the calls the
-            rule is applicable to.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCallRule">
-            <summary>
-            Allows for intercepting call to a fake object and
-            act upon them.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets whether this interceptor is applicable to the specified
-            call, if true is returned the Apply-method of the interceptor will
-            be called.
-            </summary>
-            <param name="fakeObjectCall">The call to check for applicability.</param>
-            <returns>True if the interceptor is applicable.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallRule.Apply(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies an action to the call, might set a return value or throw
-            an exception.
-            </summary>
-            <param name="fakeObjectCall">The call to apply the interceptor to.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCallRule.NumberOfTimesToCall">
-            <summary>
-            Gets the number of times this call rule is valid, if it's set
-            to null its infinitely valid.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallRuleWithDescription.WriteDescriptionOfValidCall(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a description of calls the rule is applicable to.
-            </summary>
-            <param name="writer">The writer.</param>
-        </member>
-        <member name="M:FakeItEasy.Configuration.BuildableCallRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets if this rule is applicable to the specified call.
-            </summary>
-            <param name="fakeObjectCall">The call to validate.</param>
-            <returns>True if the rule applies to the call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.BuildableCallRule.WriteDescriptionOfValidCall(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a description of calls the rule is applicable to.
-            </summary>
-            <param name="writer">The writer to write the description to.</param>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.Applicator">
-            <summary>
-            Gets or sets an action that is called by the Apply method to apply this
-            rule to a fake object call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.Actions">
-            <summary>
-            Gets a collection of actions that should be invoked when the configured
-            call is made.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.OutAndRefParametersValues">
-            <summary>
-            Gets or sets values to apply to output and reference variables.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.CallBaseMethod">
-            <summary>
-            Gets or sets a value indicating whether the base method of the fake object call should be
-            called when the fake object call is made.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.NumberOfTimesToCall">
-            <summary>
-            Gets or sets the number of times the configured rule should be used.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.DescriptionOfValidCall">
-            <summary>
-            Gets a description of calls the rule is applicable to.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAnyCallConfigurationWithNoReturnTypeSpecified">
-            <summary>
-            Configuration for any call to a faked object.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IWhereConfiguration`1">
-            <summary>
-            Provides a way to configure predicates for when a call should be applied.
-            </summary>
-            <typeparam name="T">The type of fake object that is going to be configured..</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IWhereConfiguration`1.Where(System.Func{FakeItEasy.Core.IFakeObjectCall,System.Boolean},System.Action{FakeItEasy.IOutputWriter})">
-            <summary>
-            Applies a predicate to constrain which calls will be considered for interception.
-            </summary>
-            <param name="predicate">A predicate for a fake object call.</param>
-            <param name="descriptionWriter">An action that writes a description of the predicate
-            to the output.</param>
-            <returns>The configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IVoidArgumentValidationConfiguration">
-            <summary>
-            Provides configuration methods for methods that does not have a return value and
-            allows the use to specify validations for arguments.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IVoidConfiguration">
-            <summary>
-            Provides configuration methods for methods that does not have a return value.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IExceptionThrowerConfiguration">
-            <summary>
-            Configuration that lets the developer specify that an exception should be
-            thrown by a fake object call.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IHideObjectMembers">
-            <summary>
-            Hides standard Object members to make fluent interfaces
-            easier to read. Found in the source of Autofac: <see cref="!:http://code.google.com/p/autofac/"/>
-            Based on blog post here:
-            <see cref="!:http://www.clariusconsulting.net/blogs/kzu/archive/2008/03/10/58301.aspx"/>
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.ToString">
-            <summary>
-            Hides the ToString-method.
-            </summary>
-            <returns>A string representation of the implementing object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.Equals(System.Object)">
-            <summary>
-            Determines whether the specified <see cref="T:System.Object"/> is equal to this instance.
-            </summary>
-            <param name="o">The <see cref="T:System.Object"/> to compare with this instance.</param>
-            <returns>
-            <c>true</c> if the specified <see cref="T:System.Object"/> is equal to this instance; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.GetHashCode">
-            <summary>
-            Returns a hash code for this instance.
-            </summary>
-            <returns>
-            A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.GetType">
-            <summary>
-            Gets the type.
-            </summary>
-            <returns>The exact runtime type of the current instance.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IExceptionThrowerConfiguration.Throws(System.Func{FakeItEasy.Core.IFakeObjectCall,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="exceptionFactory">A function that creates the exception to throw.</param>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.ICallbackConfiguration`1">
-            <summary>
-            Configuration for callbacks of fake object calls.
-            </summary>
-            <typeparam name="TInterface">The type of interface to return.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.ICallbackConfiguration`1.Invokes(System.Action{FakeItEasy.Core.IFakeObjectCall})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="action">The action to invoke.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.ICallBaseConfiguration">
-            <summary>
-            Configuration that lets you specify that a fake object call should call it's base method.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.ICallBaseConfiguration.CallsBaseMethod">
-            <summary>
-            When the configured method or methods are called the call
-            will be delegated to the base method of the faked method.
-            </summary>
-            <returns>A configuration object.</returns>
-            <exception cref="T:System.InvalidOperationException">The fake object is of an abstract type or an interface
-            and no base method exists.</exception>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IOutAndRefParametersConfiguration">
-            <summary>
-            Lets the developer configure output values of out and ref parameters.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IOutAndRefParametersConfiguration.AssignsOutAndRefParameters(System.Object[])">
-            <summary>
-            Specifies output values for out and ref parameters. Specify the values in the order
-            the ref and out parameters has in the configured call, any non out and ref parameters are ignored.
-            </summary>
-            <param name="values">The values.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAssertConfiguration">
-            <summary>
-            Allows the developer to assert on a call that's configured.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IAssertConfiguration.MustHaveHappened(FakeItEasy.Repeated)">
-            <summary>
-            Asserts that the configured call has happened the number of times
-            constrained by the repeatConstraint parameter.
-            </summary>
-            <param name="repeatConstraint">A constraint for how many times the call
-            must have happened.</param>
-            <exception cref="T:FakeItEasy.ExpectationException">The call has not been called a number of times
-            that passes the repeat constraint.</exception>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IVoidConfiguration.DoesNothing">
-            <summary>
-            Configures the specified call to do nothing when called.
-            </summary>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IArgumentValidationConfiguration`1">
-            <summary>
-            Provides configurations to validate arguments of a fake object call.
-            </summary>
-            <typeparam name="TInterface">The type of interface to return.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IArgumentValidationConfiguration`1.WhenArgumentsMatch(System.Func{FakeItEasy.ArgumentCollection,System.Boolean})">
-            <summary>
-            Configures the call to be accepted when the specified predicate returns true.
-            </summary>
-            <param name="argumentsPredicate">The argument predicate.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IAnyCallConfigurationWithNoReturnTypeSpecified.WithReturnType``1">
-            <summary>
-            Matches calls that has the return type specified in the generic type parameter.
-            </summary>
-            <typeparam name="TMember">The return type of the members to configure.</typeparam>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.IoC.Module">
-            <summary>
-            Manages registration of a set of components in a DictionaryContainer.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IoC.Module.RegisterDependencies(FakeItEasy.IoC.DictionaryContainer)">
-            <summary>
-            Registers the components of this module.
-            </summary>
-            <param name="container">The container to register components in.</param>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRecordingCallRuleFactory">
-            <summary>
-            A factory that creates instances of the RecordingCallRuleType.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IRecordingCallRuleFactory.Create``1(FakeItEasy.Core.FakeManager,FakeItEasy.Configuration.RecordedCallRule)">
-            <summary>
-            Creates the specified fake object.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-            <param name="fakeObject">The fake object the rule belongs to.</param>
-            <param name="recordedRule">The rule that's being recorded.</param>
-            <returns>A RecordingCallRule instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IStartConfigurationFactory">
-            <summary>
-            A factory responsible for creating start configuration for fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfigurationFactory.CreateConfiguration``1(FakeItEasy.Core.FakeManager)">
-            <summary>
-            Creates a start configuration for the specified fake object that fakes the
-            specified type.
-            </summary>
-            <typeparam name="TFake">The type of the fake object.</typeparam>
-            <param name="fakeObject">The fake object to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.FakeConfigurationException">
-            <summary>
-            An exception that can be thrown when something goes wrong with the configuration
-            of a fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
-            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
-            <exception cref="T:System.ArgumentNullException">
-            The <paramref name="info"/> parameter is null.
-            </exception>
-            <exception cref="T:System.Runtime.Serialization.SerializationException">
-            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
-            </exception>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IFakeConfigurationManager">
-            <summary>
-            Handles the configuration of fake object given an expression specifying
-            a call on a faked object.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAfterCallSpecifiedConfiguration">
-            <summary>
-            Lets you set up expectations and configure repeat for the configured call.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRepeatConfiguration">
-            <summary>
-            Provides configuration for method calls that has a return value.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IRepeatConfiguration.NumberOfTimes(System.Int32)">
-            <summary>
-            Specifies the number of times for the configured event.
-            </summary>
-            <param name="numberOfTimesToRepeat">The number of times to repeat.</param>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAfterCallSpecifiedWithOutAndRefParametersConfiguration">
-            <summary>
-            A combination of the IAfterCallSpecifiedConfiguration and IOutAndRefParametersConfiguration
-            interfaces.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAnyCallConfigurationWithReturnTypeSpecified`1">
-            <summary>
-            Aggregate of IReturnValueArgumentValidationConfiguration&lt;T&gt; and IWhereConfiguration&lt;IAnyCallConfigurationWithReturnTypeSpecified&lt;T&gt;&gt;.
-            </summary>
-            <typeparam name="T">The type of fake object that is configured.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IReturnValueArgumentValidationConfiguration`1">
-            <summary>
-            Configures a call that returns a value and allows the use to
-            specify validations for arguments.
-            </summary>
-            <typeparam name="TMember">The type of the member.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IReturnValueConfiguration`1">
-            <summary>
-            Configures a call that returns a value.
-            </summary>
-            <typeparam name="TMember">The type of the member.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IReturnValueConfiguration`1.ReturnsLazily(System.Func{FakeItEasy.Core.IFakeObjectCall,`0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRecordingConfiguration">
-            <summary>
-            Configurations for when a configured call is recorded.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRecordingConfigurationWithArgumentValidation">
-            <summary>
-            Provides configuration from VisualBasic.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IStartConfiguration`1">
-            <summary>
-            Provides methods for configuring a fake object.
-            </summary>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfiguration`1.CallsTo``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <typeparam name="TMember">The type of the return value of the member.</typeparam>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfiguration`1.CallsTo(System.Linq.Expressions.Expression{System.Action{`0}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfiguration`1.AnyCall">
-            <summary>
-            Configures the behavior of the fake object when a call is made to any method on the
-            object.
-            </summary>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.RecordedCallRule">
-            <summary>
-            A call rule that has been recorded.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.RecordingCallRule`1">
-            <summary>
-            A call rule that "sits and waits" for the next call, when
-            that call occurs the recorded rule is added for that call.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Core.ICallCollectionAndCallMatcherAccessor">
-            <summary>
-            Provides access to a set of calls and a call matcher for these calls.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ICallMatcherAccessor">
-            <summary>
-            Provides access to a call matcher.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ICallMatcherAccessor.Matcher">
-            <summary>
-            Gets a call predicate that can be used to check if a fake object call matches
-            the specified constraint.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ICallCollectionAndCallMatcherAccessor.Calls">
-            <summary>
-            Gets the set of calls.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.RuleBuilder.Factory">
-            <summary>
-            Represents a delegate that creates a configuration object from
-            a fake object and the rule to build.
-            </summary>
-            <param name="ruleBeingBuilt">The rule that's being built.</param>
-            <param name="fakeObject">The fake object the rule is for.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.ICallMatcher">
-            <summary>
-            Represents a predicate that matches a fake object call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ICallMatcher.Matches(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets a value indicating whether the call matches the predicate.
-            </summary>
-            <param name="fakeObjectCall">The call to match.</param>
-            <returns>True if the call matches the predicate.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configure">
-            <summary>
-            Provides configuration of faked objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configure.Fake``1(``0)">
-            <summary>
-            Gets a configuration for the specified faked object.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-            <param name="fakedObject">The faked object to configure.</param>
-            <returns>A configuration object.</returns>
-            <exception cref="T:System.ArgumentException">The specified object is not a faked object.</exception>
-            <exception cref="T:System.ArgumentNullException">The fakedObject parameter was null.</exception>
-        </member>
-        <member name="T:FakeItEasy.Core.ApplicationDirectoryAssembliesTypeCatalogue">
-            <summary>
-            Access all types in all assemblies in the same directory as the FakeItEasy assembly.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ITypeCatalogue">
-            <summary>
-            Provides a set of types that are available.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ITypeCatalogue.GetAvailableTypes">
-            <summary>
-            Gets a collection of available types.
-            </summary>
-            <returns>The available types.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.ApplicationDirectoryAssembliesTypeCatalogue.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.ApplicationDirectoryAssembliesTypeCatalogue"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ApplicationDirectoryAssembliesTypeCatalogue.GetAvailableTypes">
-            <summary>
-            Gets a collection of available types.
-            </summary>
-            <returns>The available types.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.ArgumentInfo">
-            <summary>
-            Represents an argument and a dummy value to use for that argument.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ArgumentInfo.#ctor(System.Boolean,System.Type,System.Object)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.ArgumentInfo"/> class.
-            </summary>
-            <param name="wasSuccessfullyResolved">A value indicating if the dummy value was successfully resolved.</param>
-            <param name="typeOfArgument">The type of argument.</param>
-            <param name="resolvedValue">The resolved value.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.ArgumentInfo.WasSuccessfullyResolved">
-            <summary>
-            Gets a value indicating whether a dummy argument value was successfully
-            resolved.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ArgumentInfo.TypeOfArgument">
-            <summary>
-            Gets the type of the argument.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ArgumentInfo.ResolvedValue">
-            <summary>
-            Gets the resolved value.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ArgumentValueFormatter.RangedFormatter">
-            <summary>
-            Holds a formatter as well as the distance between a type to be formatted
-            and the type for which the formatted is registered.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.CallInterceptedEventArgs">
-            <summary>
-            Represents an event that happens when a call has been intercepted by a proxy.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.CallInterceptedEventArgs.#ctor(FakeItEasy.Core.IWritableFakeObjectCall)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.CallInterceptedEventArgs"/> class.
-            </summary>
-            <param name="call">The call.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.CallInterceptedEventArgs.Call">
-            <summary>
-            Gets the call that was intercepted.
-            </summary>
-            <value>The call.</value>
-        </member>
-        <member name="T:FakeItEasy.Core.CallRuleMetadata">
-            <summary>
-            Keeps track of metadata for interceptions.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.CallRuleMetadata.HasNotBeenCalledSpecifiedNumberOfTimes">
-            <summary>
-            Gets whether the rule has been called the number of times specified or not.
-            </summary>
-            <returns>True if the rule has not been called the number of times specified.</returns>
-        </member>
-        <member name="P:FakeItEasy.Core.CallRuleMetadata.CalledNumberOfTimes">
-            <summary>
-            Gets or sets the number of times the rule has been used.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.CallRuleMetadata.Rule">
-            <summary>
-            Gets or sets the rule this metadata object is tracking.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.IArgumentConstraintManager`1">
-            <summary>
-            Manages attaching of argument constraints.
-            </summary>
-            <typeparam name="T">The type of argument to constrain.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.IArgumentConstraintManager`1.Matches(System.Func{`0,System.Boolean},System.Action{FakeItEasy.IOutputWriter})">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="predicate">The predicate that should constrain the argument.</param>
-            <param name="descriptionWriter">An action that will be write a description of the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="P:FakeItEasy.IArgumentConstraintManager`1.Not">
-            <summary>
-            Inverts the logic of the matches method.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IArgumentConstraint">
-            <summary>
-            Validates an argument, checks that it's valid in a specific fake call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IArgumentConstraint.WriteDescription(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a description of the argument constraint to the specified writer.
-            </summary>
-            <param name="writer">
-            The writer.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Core.IArgumentConstraint.IsValid(System.Object)">
-            <summary>
-            Gets whether the argument is valid.
-            </summary>
-            <param name="argument">The argument to validate.</param>
-            <returns>True if the argument is valid.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.DefaultFakeManagerAccessor">
-            <summary>
-            Default implementation of <see cref="T:FakeItEasy.Core.IFakeManagerAccessor"/>.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeManagerAccessor">
-            <summary>
-            Attaches a fake manager to the proxy so that intercepted
-            calls can be configured.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeManagerAccessor.AttachFakeManagerToProxy(System.Type,System.Object,FakeItEasy.Creation.ICallInterceptedEventRaiser)">
-            <summary>
-            Attaches a <see cref="T:FakeItEasy.Core.FakeManager"/> to the specified proxy, listening to
-            the event raiser.
-            </summary>
-            <param name="typeOfFake">The type of the fake object proxy.</param>
-            <param name="proxy">The proxy to attach to.</param>
-            <param name="eventRaiser">The event raiser to listen to.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeManagerAccessor.GetFakeManager(System.Object)">
-            <summary>
-            Gets the fake manager associated with the proxy.
-            </summary>
-            <param name="proxy">The proxy to get the manager from.</param>
-            <returns>A fake manager.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeManagerAccessor.AttachFakeManagerToProxy(System.Type,System.Object,FakeItEasy.Creation.ICallInterceptedEventRaiser)">
-            <summary>
-            Attaches a <see cref="T:FakeItEasy.Core.FakeManager"/> to the specified proxy, listening to
-            the event raiser.
-            </summary>
-            <param name="typeOfFake">The type of the fake object proxy.</param>
-            <param name="proxy">The proxy to attach to.</param>
-            <param name="eventRaiser">The event raiser to listen to.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeManagerAccessor.GetFakeManager(System.Object)">
-            <summary>
-            Gets the fake manager associated with the proxy.
-            </summary>
-            <param name="proxy">The proxy to get the manager from.</param>
-            <returns>A fake manager.</returns>
-        </member>
-        <member name="T:FakeItEasy.Creation.ITaggable">
-            <summary>
-            Represents an object that can be tagged with another object. When implemented
-            by a proxy returned from an <see cref="T:FakeItEasy.Creation.IProxyGenerator"/> FakeItEasy uses the tag
-            to store a reference to the <see cref="T:FakeItEasy.Core.FakeManager"/> that handles that proxy.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ITaggable.Tag">
-            <summary>
-            Gets or sets the tag.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.DefaultFakeObjectCallFormatter">
-            <summary>
-            The default implementation of the IFakeObjectCallFormatter interface.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCallFormatter">
-            <summary>
-            Provides string formatting for fake object calls.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallFormatter.GetDescription(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets a human readable description of the specified
-            fake object call.
-            </summary>
-            <param name="call">The call to get a description for.</param>
-            <returns>A description of the call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeObjectCallFormatter.GetDescription(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets a human readable description of the specified
-            fake object call.
-            </summary>
-            <param name="call">The call to get a description for.</param>
-            <returns>A description of the call.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.DefaultFakeWrapperConfigurer">
-            <summary>
-            Handles configuring of fake objects to delegate all their calls to a wrapped instance.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeWrapperConfigurer">
-            <summary>
-            Manages configuration of fake objects to wrap instances.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeWrapperConfigurer.ConfigureFakeToWrap(System.Object,System.Object,FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Configures the specified faked object to wrap the specified instance.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <param name="wrappedInstance">The instance to wrap.</param>
-            <param name="recorder">The recorder to use, null if no recording should be made.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeWrapperConfigurer.ConfigureFakeToWrap(System.Object,System.Object,FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Configures the specified faked object to wrap the specified instance.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <param name="wrappedInstance">The instance to wrap.</param>
-            <param name="recorder">The recorder to use, null if no recording should be made.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.DelegateFakeObjectContainer">
-            <summary>
-            A fake object container where delegates can be registered that are used to
-            resolve fake objects.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectContainer">
-            <summary>
-            A container that can create fake objects.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectConfigurator">
-            <summary>
-            Handles global configuration of fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectConfigurator.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Applies base configuration to a fake object.
-            </summary>
-            <param name="typeOfFake">The type the fake object represents.</param>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Creates a dummy object of the specified type using the specified arguments if it's
-            supported by the container, returns a value indicating if it's supported or not.
-            </summary>
-            <param name="typeOfDummy">The type of dummy object to create.</param>
-            <param name="fakeObject">The dummy object that was created if the method returns true.</param>
-            <returns>True if a dummy object can be created.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.DelegateFakeObjectContainer"/> class. 
-            Creates a new instance of the DelegateFakeObjectContainer.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Creates a fake object of the specified type using the specified arguments if it's
-            supported by the container, returns a value indicating if it's supported or not.
-            </summary>
-            <param name="typeOfDummy">The type of dummy object to create.</param>
-            <param name="fakeObject">The fake object that was created if the method returns true.</param>
-            <returns>True if a fake object can be created.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Configures the fake.
-            </summary>
-            <param name="typeOfFake">The type of fake.</param>
-            <param name="fakeObject">The fake object.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.Register``1(System.Func{``0})">
-            <summary>
-            Registers the specified fake delegate.
-            </summary>
-            <typeparam name="T">The type of the return value of the method that <paramref name="fakeDelegate"/> encapsulates.</typeparam>
-            <param name="fakeDelegate">The fake delegate.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.DynamicContainer">
-            <summary>
-            A IFakeObjectContainer implementation that uses MEF to load IFakeDefinitions and
-            IFakeConfigurations.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.DynamicContainer.#ctor(System.Collections.Generic.IEnumerable{FakeItEasy.IDummyDefinition},System.Collections.Generic.IEnumerable{FakeItEasy.IFakeConfigurator})">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.DynamicContainer"/> class.
-            </summary>
-            <param name="dummyDefinitions">The dummy definitions.</param>
-            <param name="fakeConfigurators">The fake configurators.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DynamicContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Creates a fake object of the specified type using the specified arguments if it's
-            supported by the container, returns a value indicating if it's supported or not.
-            </summary>
-            <param name="typeOfDummy">The type of fake object to create.</param>
-            <param name="fakeObject">The fake object that was created if the method returns true.</param>
-            <returns>True if a fake object can be created.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DynamicContainer.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Applies base configuration to a fake object.
-            </summary>
-            <param name="typeOfFake">The type the fake object represents.</param>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeCreationException">
-            <summary>
-            An exception that is thrown when there was an error creating a fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
-            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
-            <exception cref="T:System.ArgumentNullException">
-            The <paramref name="info"/> parameter is null.
-            </exception>
-            <exception cref="T:System.Runtime.Serialization.SerializationException">
-            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
-            </exception>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeManager">
-            <content>Auto fake property rule.</content>
-            <summary>
-            The central point in the API for proxied fake objects handles interception
-            of fake object calls by using a set of rules. User defined rules can be inserted
-            by using the AddRule-method.
-            </summary>
-            <content>Event rule.</content>
-            <content>Object member rule.</content>
-            <content>Property behavior rule.</content>
-            <content>Property setter rule.</content>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeManager"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.AddRuleFirst(FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Adds a call rule to the fake object.
-            </summary>
-            <param name="rule">The rule to add.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.AddRuleLast(FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Adds a call rule last in the list of user rules, meaning it has the lowest priority possible.
-            </summary>
-            <param name="rule">The rule to add.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.RemoveRule(FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Removes the specified rule for the fake object.
-            </summary>
-            <param name="rule">The rule to remove.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.AddInterceptionListener(FakeItEasy.Core.IInterceptionListener)">
-            <summary>
-            Adds an interception listener to the manager.
-            </summary>
-            <param name="listener">The listener to add.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.ClearUserRules">
-            <summary>
-            Removes any specified user rules.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.Object">
-            <summary>
-            Gets the faked object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.FakeObjectType">
-            <summary>
-            Gets the faked type.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.Rules">
-            <summary>
-            Gets the interceptions that are currently registered with the fake object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.RecordedCallsInScope">
-            <summary>
-            Gets a collection of all the calls made to the fake object within the current scope.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeManager.Factory">
-            <summary>
-            A delegate responsible for creating FakeObject instances.
-            </summary>
-            <returns>An instance of <see cref="T:FakeItEasy.Core.FakeManager"/>.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.IInterceptedFakeObjectCall">
-            <summary>
-            Represents a call to a fake object at interception time.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IWritableFakeObjectCall">
-            <summary>
-            Represents a fake object call that can be edited.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCall">
-            <summary>
-            Represents a call to a fake object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCall.Method">
-            <summary>
-            Gets the method that's called.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCall.Arguments">
-            <summary>
-            Gets the arguments used in the call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCall.FakedObject">
-            <summary>
-            Gets the faked object the call is performed on.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.SetReturnValue(System.Object)">
-            <summary>
-            Sets the return value of the call.
-            </summary>
-            <param name="value">The return value to set.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.CallBaseMethod">
-            <summary>
-            Calls the base method of the faked type.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.SetArgumentValue(System.Int32,System.Object)">
-            <summary>
-            Sets the value of the argument at the specified index in the parameters list.
-            </summary>
-            <param name="index">The index of the argument to set the value of.</param>
-            <param name="value">The value to set to the argument.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.AsReadOnly">
-            <summary>
-            Freezes the call so that it can no longer be modified.
-            </summary>
-            <returns>A completed fake object call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.IInterceptedFakeObjectCall.DoNotRecordCall">
-            <summary>
-            Sets that the call should not be recorded by the fake manager.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeScope">
-            <summary>
-            Represents a scope for fake objects, calls configured within a scope
-            are only valid within that scope. Only calls made within a scope
-            are accessible from within a scope so for example asserts will only
-            assert on those calls done within the scope.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeScope">
-            <summary>
-            Provides access to all calls made to fake objects within a scope.
-            Scopes calls so that only calls made within the scope are visible.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.Create">
-            <summary>
-            Creates a new scope and sets it as the current scope.
-            </summary>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.Create(FakeItEasy.Core.IFakeObjectContainer)">
-            <summary>
-            Creates a new scope and sets it as the current scope, using the specified
-            container as the container for the new scope.
-            </summary>
-            <param name="container">The container to use for the new scope.</param>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.Dispose">
-            <summary>
-            Closes the scope.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.AddInterceptedCall(FakeItEasy.Core.FakeManager,FakeItEasy.Core.ICompletedFakeObjectCall)">
-            <summary>
-            Adds an intercepted call to the current scope.
-            </summary>
-            <param name="fakeManager">The fake object.</param>
-            <param name="call">The call that is intercepted.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.AddRuleFirst(FakeItEasy.Core.FakeManager,FakeItEasy.Core.CallRuleMetadata)">
-            <summary>
-            Adds a fake object call to the current scope.
-            </summary>
-            <param name="fakeManager">The fake object.</param>
-            <param name="rule">The rule to add.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.ICompletedFakeObjectCall">
-            <summary>
-            Represents a completed call to a fake object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ICompletedFakeObjectCall.ReturnValue">
-            <summary>
-            Gets the value set to be returned from the call.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IEventRaiserArguments">
-            <summary>
-            Used by the event raising rule of fake objects to get the event arguments used in
-            a call to Raise.With.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IEventRaiserArguments.Sender">
-            <summary>
-            Gets the sender of the event.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IEventRaiserArguments.EventArguments">
-            <summary>
-            Gets the event arguments of the event.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IInterceptionListener">
-            <summary>
-            Represents a listener for fake object calls, can be plugged into a
-            FakeManager instance to listen to all intercepted calls.
-            </summary>
-            <remarks>The OnBeforeCallIntercepted method will be invoked before the OnBeforeCallIntercepted method of any
-            previously added listener. The OnAfterCallIntercepted method will be invoked after the OnAfterCallIntercepted
-            method of any previously added listener.</remarks>
-        </member>
-        <member name="M:FakeItEasy.Core.IInterceptionListener.OnBeforeCallIntercepted(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Called when the interception begins but before any call rules
-            has been applied.
-            </summary>
-            <param name="interceptedCall">The intercepted call.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IInterceptionListener.OnAfterCallIntercepted(FakeItEasy.Core.ICompletedFakeObjectCall,FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Called when the interception has been completed and rules has been
-            applied.
-            </summary>
-            <param name="interceptedCall">The intercepted call.</param>
-            <param name="ruleThatWasApplied">The rule that was applied to the call.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.MethodInfoManager">
-            <summary>
-            Handles comparisons of instances of <see cref="T:System.Reflection.MethodInfo"/>.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.MethodInfoManager.WillInvokeSameMethodOnTarget(System.Type,System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
-            <summary>
-            Gets a value indicating whether the two instances of <see cref="T:System.Reflection.MethodInfo"/> would invoke the same method
-            if invoked on an instance of the target type.
-            </summary>
-            <param name="target">The type of target for invocation.</param>
-            <param name="first">The first <see cref="T:System.Reflection.MethodInfo"/>.</param>
-            <param name="second">The second <see cref="T:System.Reflection.MethodInfo"/>.</param>
-            <returns>True if the same method would be invoked.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.NullFakeObjectContainer">
-            <summary>
-            A null implementation for the IFakeObjectContainer interface.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.NullFakeObjectContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Always returns false and sets the fakeObject to null.
-            </summary>
-            <param name="typeOfDummy">The type of dummy object to create.</param>
-            <param name="fakeObject">Output variable for the fake object that will always be set to null.</param>
-            <returns>Always return false.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.NullFakeObjectContainer.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Applies base configuration to a fake object.
-            </summary>
-            <param name="typeOfFake">The type the fake object represents.</param>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.TypeCatalogueInstanceProvider">
-            <summary>
-            Provides instances from type catalogues.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.TypeCatalogueInstanceProvider.InstantiateAllOfType``1">
-            <summary>
-            Gets an instance per type in the catalogue that is a descendant
-            of the specified type.
-            </summary>
-            <typeparam name="T">The type of instances to get.</typeparam>
-            <returns>A sequence of instances of the specified type.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.WrappedObjectRule">
-            <summary>
-            A call rule that applies to any call and just delegates the
-            call to the wrapped object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.WrappedObjectRule.#ctor(System.Object)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.WrappedObjectRule"/> class. 
-            Creates a new instance.
-            </summary>
-            <param name="wrappedInstance">
-            The object to wrap.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Core.WrappedObjectRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets whether this interceptor is applicable to the specified
-            call, if true is returned the Apply-method of the interceptor will
-            be called.
-            </summary>
-            <param name="fakeObjectCall">The call to check for applicability.</param>
-            <returns>True if the interceptor is applicable.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.WrappedObjectRule.Apply(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies an action to the call, might set a return value or throw
-            an exception.
-            </summary>
-            <param name="fakeObjectCall">The call to apply the interceptor to.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.WrappedObjectRule.NumberOfTimesToCall">
-            <summary>
-            Gets the number of times this call rule is valid, if it's set
-            to null its infinitely valid.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.Creation.IProxyGenerator">
-            <summary>
-            An interface to be implemented by classes that can generate proxies for FakeItEasy.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.IProxyGenerator.GenerateProxy(System.Type,System.Collections.Generic.IEnumerable{System.Type},System.Collections.Generic.IEnumerable{System.Object},System.Collections.Generic.IEnumerable{System.Reflection.Emit.CustomAttributeBuilder})">
-            <summary>
-            Generates a proxy of the specified type and returns a result object containing information
-            about the success of the generation and the proxy if it was generated.
-            </summary>
-            <param name="typeOfProxy">The type of proxy to generate.</param>
-            <param name="additionalInterfacesToImplement">Interfaces to be implemented by the proxy.</param>
-            <param name="argumentsForConstructor">Arguments to pass to the constructor of the type in <paramref name="typeOfProxy" />.</param>
-            <param name="customAttributeBuilders">The custom attribute builders.</param>
-            <returns>A result containing the generated proxy.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IProxyGenerator.GenerateProxy(System.Type,System.Collections.Generic.IEnumerable{System.Type},System.Collections.Generic.IEnumerable{System.Object})">
-            <summary>
-            Generates a proxy of the specified type and returns a result object containing information
-            about the success of the generation and the proxy if it was generated.
-            </summary>
-            <param name="typeOfProxy">The type of proxy to generate.</param>
-            <param name="additionalInterfacesToImplement">Interfaces to be implemented by the proxy.</param>
-            <param name="argumentsForConstructor">Arguments to pass to the constructor of the type in <paramref name="typeOfProxy" />.</param>
-            <returns>A result containing the generated proxy.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IProxyGenerator.MethodCanBeInterceptedOnInstance(System.Reflection.MethodInfo,System.Object,System.String@)">
-            <summary>
-            Gets a value indicating whether the specified member can be intercepted by the proxy generator.
-            </summary>
-            <param name="method">The member to test.</param>
-            <param name="callTarget">The instance the method will be called on.</param>
-            <param name="failReason">The reason the method can not be intercepted.</param>
-            <returns>True if the member can be intercepted.</returns>
-        </member>
-        <member name="T:FakeItEasy.Creation.ICallInterceptedEventRaiser">
-            <summary>
-            An object that raises an event every time a call to a proxy has been intercepted.
-            </summary>
-        </member>
-        <member name="E:FakeItEasy.Creation.ICallInterceptedEventRaiser.CallWasIntercepted">
-            <summary>
-            Raised when a call is intercepted.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter">
-            <summary>
-            An adapter that adapts an <see cref="T:Castle.DynamicProxy.IInvocation"/> to a <see cref="T:FakeItEasy.Core.IFakeObjectCall"/>.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.#ctor(Castle.DynamicProxy.IInvocation)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter"/> class.
-            </summary>
-            <param name="invocation">The invocation.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.AsReadOnly">
-            <summary>
-            Freezes the call so that it can no longer be modified.
-            </summary>
-            <returns>A completed fake object call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.CallBaseMethod">
-            <summary>
-            Calls the base method, should not be used with interface types.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.SetArgumentValue(System.Int32,System.Object)">
-            <summary>
-            Sets the specified value to the argument at the specified index.
-            </summary>
-            <param name="index">The index of the argument to set the value to.</param>
-            <param name="value">The value to set to the argument.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.SetReturnValue(System.Object)">
-            <summary>
-            Sets the return value of the call.
-            </summary>
-            <param name="returnValue">The return value.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.ToString">
-            <summary>
-            Returns a description of the call.
-            </summary>
-            <returns>
-            A <see cref="T:System.String"/> that represents this instance.
-            </returns>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.Description">
-            <summary>
-            Gets a human readable description of the call.
-            </summary>
-            <value></value>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.ReturnValue">
-            <summary>
-            Gets the value set to be returned from the call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.Method">
-            <summary>
-            Gets the method that's called.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.Arguments">
-            <summary>
-            Gets the arguments used in the call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.FakedObject">
-            <summary>
-            Gets the faked object the call is performed on.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources">
-            <summary>
-              A strongly-typed resource class, for looking up localized strings, etc.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ResourceManager">
-            <summary>
-              Returns the cached ResourceManager instance used by this class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.Culture">
-            <summary>
-              Overrides the current thread's CurrentUICulture property for all
-              resource lookups using this strongly typed resource class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ArgumentsForConstructorDoesNotMatchAnyConstructorMessage">
-            <summary>
-              Looks up a localized string similar to No constructor matches the passed arguments for constructor..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ArgumentsForConstructorOnInterfaceTypeMessage">
-            <summary>
-              Looks up a localized string similar to Arguments for constructor specified for interface type..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ProxyIsSealedTypeMessage">
-            <summary>
-              Looks up a localized string similar to The type of proxy &quot;{0}&quot; is sealed..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ProxyIsValueTypeMessage">
-            <summary>
-              Looks up a localized string similar to The type of proxy must be an interface or a class but it was {0}..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ProxyTypeWithNoDefaultConstructorMessage">
-            <summary>
-              Looks up a localized string similar to No usable default constructor was found on the type {0}..
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.DefaultFakeAndDummyManager">
-            <summary>
-            The default implementation of the IFakeAndDummyManager interface.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeAndDummyManager">
-            <summary>
-            Handles the creation of fake and dummy objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.CreateDummy(System.Type)">
-            <summary>
-            Creates a dummy of the specified type.
-            </summary>
-            <param name="typeOfDummy">The type of dummy to create.</param>
-            <returns>The created dummy.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">The current IProxyGenerator is not able to generate a fake of the specified type and
-            the current IFakeObjectContainer does not contain the specified type.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.CreateFake(System.Type,FakeItEasy.Creation.FakeOptions)">
-            <summary>
-            Creates a fake object of the specified type.
-            </summary>
-            <param name="typeOfFake">The type of fake object to generate.</param>
-            <param name="options">Options for building the fake object.</param>
-            <returns>A fake object.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">The current IProxyGenerator is not able to generate a fake of the specified type.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.TryCreateDummy(System.Type,System.Object@)">
-            <summary>
-            Tries to create a dummy of the specified type.
-            </summary>
-            <param name="typeOfDummy">The type of dummy to create.</param>
-            <param name="result">Outputs the result dummy when creation is successful.</param>
-            <returns>A value indicating whether the creation was successful.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.TryCreateFake(System.Type,FakeItEasy.Creation.FakeOptions,System.Object@)">
-            <summary>
-            Tries to create a fake object of the specified type.
-            </summary>
-            <param name="typeOfFake">The type of fake to create.</param>
-            <param name="options">Options for the creation of the fake.</param>
-            <param name="result">The created fake object when creation is successful.</param>
-            <returns>A value indicating whether the creation was successful.</returns>
-        </member>
-        <member name="T:FakeItEasy.Creation.DefaultFakeCreatorFacade">
-            <summary>
-            Default implementation of the IFakeCreator-interface.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeCreatorFacade">
-            <summary>
-            A facade used by the public API for testability.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeCreatorFacade.CreateFake``1(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{``0}})">
-            <summary>
-            Creates a fake object of the specified type.
-            </summary>
-            <typeparam name="T">The type of fake to create.</typeparam>
-            <param name="options">Options for the created fake object.</param>
-            <returns>The created fake object.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeCreatorFacade.CreateDummy``1">
-            <summary>
-            Creates a dummy object, this can be a fake object or an object resolved
-            from the current IFakeObjectContainer.
-            </summary>
-            <typeparam name="T">The type of dummy to create.</typeparam>
-            <returns>The created dummy.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration and
-            no dummy was registered in the container for the specified type..</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeCreatorFacade.CollectionOfFake``1(System.Int32)">
-            <summary>
-            Creates a collection of fakes of the specified type.
-            </summary>
-            <typeparam name="T">The type of fakes to create.</typeparam>
-            <param name="numberOfFakes">The number of fakes in the collection.</param>
-            <returns>A collection of fake objects of the specified type.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.#ctor(FakeItEasy.Creation.IFakeAndDummyManager)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.DefaultFakeCreatorFacade"/> class.
-            </summary>
-            <param name="fakeAndDummyManager">The fake and dummy manager.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.CreateFake``1(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{``0}})">
-            <summary>
-            Creates a fake object of the specified type.
-            </summary>
-            <typeparam name="T">The type of fake to create.</typeparam>
-            <param name="options">Options for the created fake object.</param>
-            <returns>The created fake object.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.CollectionOfFake``1(System.Int32)">
-            <summary>
-            Creates a collection of fakes of the specified type.
-            </summary>
-            <typeparam name="T">The type of fakes to create.</typeparam>
-            <param name="numberOfFakes">The number of fakes in the collection.</param>
-            <returns>
-            A collection of fake objects of the specified type.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.CreateDummy``1">
-            <summary>
-            Creates a dummy object, this can be a fake object or an object resolved
-            from the current IFakeObjectContainer.
-            </summary>
-            <typeparam name="T">The type of dummy to create.</typeparam>
-            <returns>The created dummy.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration and
-            no dummy was registered in the container for the specified type..</exception>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeOptionsBuilderForWrappers`1">
-            <summary>
-            Provides options for fake wrappers.
-            </summary>
-            <typeparam name="T">The type of the fake object generated.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeOptionsBuilder`1">
-            <summary>
-            Provides options for generating fake object.
-            </summary>
-            <typeparam name="T">The type of fake object generated.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.WithArgumentsForConstructor(System.Collections.Generic.IEnumerable{System.Object})">
-            <summary>
-            Specifies arguments for the constructor of the faked class.
-            </summary>
-            <param name="argumentsForConstructor">The arguments to pass to the constructor of the faked class.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.WithArgumentsForConstructor(System.Linq.Expressions.Expression{System.Func{`0}})">
-            <summary>
-            Specifies arguments for the constructor of the faked class by giving an expression with the call to
-            the desired constructor using the arguments to be passed to the constructor.
-            </summary>
-            <param name="constructorCall">The constructor call to use when creating a class proxy.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.Wrapping(`0)">
-            <summary>
-            Specifies that the fake should delegate calls to the specified instance.
-            </summary>
-            <param name="wrappedInstance">The object to delegate calls to.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.WithAdditionalAttributes(System.Collections.Generic.IEnumerable{System.Reflection.Emit.CustomAttributeBuilder})">
-            <summary>
-            Specifies that the fake should be created with these additional attributes.
-            </summary>
-            <param name="customAttributeBuilders">The attributes to build into the proxy.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.Implements(System.Type)">
-            <summary>
-            Sets up the fake to implement the specified interface in addition to the
-            originally faked class.
-            </summary>
-            <param name="interfaceType">The type of interface to implement.</param>
-            <returns>Options object.</returns>
-            <exception cref="T:System.ArgumentException">The specified type is not an interface.</exception>
-            <exception cref="T:System.ArgumentNullException">The specified type is null.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.OnFakeCreated(System.Action{`0})">
-            <summary>
-            Specifies an action that should be run over the fake object
-            once it's created.
-            </summary>
-            <param name="action">An action to perform.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilderForWrappers`1.RecordedBy(FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Specifies a fake recorder to use.
-            </summary>
-            <param name="recorder">The recorder to use.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.DummyValueCreationSession.#ctor(FakeItEasy.Core.IFakeObjectContainer,FakeItEasy.Creation.IFakeObjectCreator)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.DummyValueCreationSession"/> class.
-            </summary>
-            <param name="container">The container.</param>
-            <param name="fakeObjectCreator">The fake object creator.</param>
-        </member>
-        <member name="T:FakeItEasy.Creation.ProxyGeneratorResult">
-            <summary>
-            Contains the result of a call to TryCreateProxy of IProxyGenerator.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.ProxyGeneratorResult.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.ProxyGeneratorResult"/> class. 
-            Creates a new instance representing a failed proxy
-            generation attempt.
-            </summary>
-            <param name="reasonForFailure">
-            The reason the proxy generation failed.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Creation.ProxyGeneratorResult.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.ProxyGeneratorResult"/> class. 
-            Creates a new instance representing a failed proxy
-            generation attempt due to an exception being caught.
-            </summary>
-            <param name="reasonForFailure">
-            The reason the proxy generation failed.
-            </param>
-            <param name="exception">
-            The exception thrown from the creation attempt.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Creation.ProxyGeneratorResult.#ctor(System.Object,FakeItEasy.Creation.ICallInterceptedEventRaiser)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.ProxyGeneratorResult"/> class. 
-            Creates a new instance representing a successful proxy
-            generation.
-            </summary>
-            <param name="generatedProxy">
-            The proxy that was generated.
-            </param>
-            <param name="callInterceptedEventRaiser">
-            An event raiser that raises
-            events when calls are intercepted to the proxy.
-            </param>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.ProxyWasSuccessfullyGenerated">
-            <summary>
-            Gets a value indicating whether the proxy was successfully created.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.GeneratedProxy">
-            <summary>
-            Gets the generated proxy when it was successfully created.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.CallInterceptedEventRaiser">
-            <summary>
-            Gets the event raiser that raises events when calls to the proxy are
-            intercepted.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.ReasonForFailure">
-            <summary>
-            Gets the reason for failure when the generation was not successful.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.IOutputWriter">
-            <summary>
-            Represents a text writer that writes to the output.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IOutputWriter.Write(System.String)">
-            <summary>
-            Writes the specified value to the output.
-            </summary>
-            <param name="value">The value to write.</param>
-            <returns>The writer for method chaining.</returns>
-        </member>
-        <member name="M:FakeItEasy.IOutputWriter.WriteArgumentValue(System.Object)">
-            <summary>
-            Formats the specified argument value as a string and writes
-            it to the output.
-            </summary>
-            <param name="value">The value to write.</param>
-            <returns>The writer for method chaining.</returns>
-        </member>
-        <member name="M:FakeItEasy.IOutputWriter.Indent">
-            <summary>
-            Indents the writer.
-            </summary>
-            <returns>A disposable that will unindent the writer when disposed.</returns>
-        </member>
-        <member name="T:FakeItEasy.DummyDefinition`1">
-            <summary>
-            Represents a definition of how a fake object of the type T should
-            be created.
-            </summary>
-            <typeparam name="T">The type of fake.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.IDummyDefinition">
-            <summary>
-            Represents a definition of how dummies of the specified type should be created.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IDummyDefinition.CreateDummy">
-            <summary>
-            Creates the fake.
-            </summary>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="P:FakeItEasy.IDummyDefinition.ForType">
-            <summary>
-            Gets the type of fake object the definition is for.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.DummyDefinition`1.FakeItEasy#IDummyDefinition#CreateDummy">
-            <summary>
-            Creates the dummy.
-            </summary>
-            <returns>The dummy object.</returns>
-        </member>
-        <member name="M:FakeItEasy.DummyDefinition`1.CreateDummy">
-            <summary>
-            Creates the dummy.
-            </summary>
-            <returns>The dummy object.</returns>
-        </member>
-        <member name="P:FakeItEasy.DummyDefinition`1.ForType">
-            <summary>
-            Gets the type the definition is for.
-            </summary>
-            <value>For type.</value>
-        </member>
-        <member name="T:FakeItEasy.ExceptionMessages">
-            <summary>
-              A strongly-typed resource class, for looking up localized strings, etc.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ResourceManager">
-            <summary>
-              Returns the cached ResourceManager instance used by this class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.Culture">
-            <summary>
-              Overrides the current thread's CurrentUICulture property for all
-              resource lookups using this strongly typed resource class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ApplicatorNotSetExceptionMessage">
-            <summary>
-              Looks up a localized string similar to The Apply method of the ExpressionInterceptor may no be called before the Applicator property has been set..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ArgumentNameDoesNotExist">
-            <summary>
-              Looks up a localized string similar to The specified argument name does not exist in the ArgumentList..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ArgumentsForConstructorOnInterfaceType">
-            <summary>
-              Looks up a localized string similar to Arguments for constructor was specified when generating proxy of interface type..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ArgumentValidationDefaultMessage">
-            <summary>
-              Looks up a localized string similar to An argument validation was not configured correctly..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CalledTooFewTimesMessage">
-            <summary>
-              Looks up a localized string similar to The method &apos;{0}&apos; was called too few times, expected #{1} times but was called #{2} times..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CalledTooManyTimesMessage">
-            <summary>
-              Looks up a localized string similar to The method &apos;{0}&apos; was called too many times, expected #{1} times but was called #{2} times..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CanNotGenerateFakeMessage">
-             <summary>
-               Looks up a localized string similar to Can not create fake of the type &apos;{0}&apos;, it&apos;s not registered in the current container and the current IProxyGenerator can not generate the fake.
-            
-            The following constructors failed:
-            {1}.
-             </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ConfiguringNonFakeObjectExceptionMessage">
-            <summary>
-              Looks up a localized string similar to Error when accessing FakeObject, the specified argument is of the type &apos;{0}&apos; which is not faked..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CreatingExpressionCallMatcherWithNonMethodOrPropertyExpression">
-            <summary>
-              Looks up a localized string similar to An ExpressionCallMatcher can only be created for expressions that represents a method call or a property getter..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FailedToGenerateFakeWithArgumentsForConstructorPattern">
-             <summary>
-               Looks up a localized string similar to 
-            
-              The current proxy generator failed to create a proxy with the specified arguments for the constructor:
-            
-              Reason for failure:
-                - {0}
-              
-            .
-             </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FailedToGenerateProxyPattern">
-             <summary>
-               Looks up a localized string similar to FakeItEasy failed to create fake object of type &quot;{0}&quot;.
-            
-            1. The type is not registered in the current IFakeObjectContainer.
-            2. The current IProxyGenerator failed to generate a proxy for the following reason:
-            
-            {1}.
-             </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FakeCreationExceptionDefaultMessage">
-            <summary>
-              Looks up a localized string similar to Unable to create fake object..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FakingNonAbstractClassWithArgumentsForConstructor">
-            <summary>
-              Looks up a localized string similar to Only abstract classes can be faked using the A.Fake-method that takes an enumerable of objects as arguments for constructor, use the overload that takes an expression instead..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.MemberAccessorNotCorrectExpressionType">
-            <summary>
-              Looks up a localized string similar to The member accessor expression must be a lambda expression with a MethodCallExpression or MemberAccessExpression as its body..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.MemberCanNotBeIntercepted">
-            <summary>
-              Looks up a localized string similar to The specified method can not be configured since it can not be intercepted by the current IProxyGenerator..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.MethodMissmatchWhenPlayingBackRecording">
-            <summary>
-              Looks up a localized string similar to The method of the call did not match the method of the recorded call, the recorded sequence is no longer valid..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NoConstructorMatchingArguments">
-            <summary>
-              Looks up a localized string similar to No constructor matching the specified arguments was found on the type {0}..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NoDefaultConstructorMessage">
-            <summary>
-              Looks up a localized string similar to Can not generate fake object for the class since no usable default constructor was found, specify a constructor call..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NoMoreRecordedCalls">
-            <summary>
-              Looks up a localized string similar to All the recorded calls has been applied, the recorded sequence is no longer valid..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NonConstructorExpressionMessage">
-            <summary>
-              Looks up a localized string similar to Only expression of the type ExpressionType.New (constructor calls) are accepted..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NowCalledDirectly">
-            <summary>
-              Looks up a localized string similar to The Now-method on the event raise is not meant to be called directly, only use it to register to an event on a fake object that you want to be raised..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NumberOfOutAndRefParametersDoesNotMatchCall">
-            <summary>
-              Looks up a localized string similar to The number of values for out and ref parameters specified does not match the number of out and ref parameters in the call..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.OrderedAssertionsAlreadyOpen">
-            <summary>
-              Looks up a localized string similar to A scope for ordered assertions is already opened, close that scope before opening another one..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.SpecifiedCallIsNotToFakedObject">
-            <summary>
-              Looks up a localized string similar to The specified call is not made on a fake object..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.TypeCanNotBeProxied">
-            <summary>
-              Looks up a localized string similar to The current fake proxy generator can not create proxies of the type {0}..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.UnableToCreateDummyPattern">
-            <summary>
-              Looks up a localized string similar to FakeItEasy was unable to create dummy of type &quot;{0}&quot;, register it in the current IFakeObjectContainer to enable this..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.WasCalledWrongNumberOfTimes">
-            <summary>
-              Looks up a localized string similar to Expected to find call {0} the number of times specified by the predicate &apos;{1}&apos; but found it {2} times among the calls:.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.WrongNumberOfArgumentNamesMessage">
-            <summary>
-              Looks up a localized string similar to The number of argument names does not match the number of arguments..
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.ExpectationException">
-            <summary>
-            An exception thrown when an expectation is not met (when asserting on fake object calls).
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
-            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
-            <exception cref="T:System.ArgumentNullException">
-            The <paramref name="info"/> parameter is null.
-            </exception>
-            <exception cref="T:System.Runtime.Serialization.SerializationException">
-            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
-            </exception>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ICallExpressionParser">
-            <summary>
-            Represents a class that can parse a lambda expression
-            that represents a method or property call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ICallExpressionParser.Parse(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Parses the specified expression.
-            </summary>
-            <param name="callExpression">The expression to parse.</param>
-            <returns>The parsed expression.</returns>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionCallMatcher">
-            <summary>
-            Handles the matching of fake object calls to expressions.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallMatcher.#ctor(System.Linq.Expressions.LambdaExpression,FakeItEasy.Expressions.ExpressionArgumentConstraintFactory,FakeItEasy.Core.MethodInfoManager,FakeItEasy.Expressions.ICallExpressionParser)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Expressions.ExpressionCallMatcher"/> class.
-            </summary>
-            <param name="callSpecification">The call specification.</param>
-            <param name="constraintFactory">The constraint factory.</param>
-            <param name="methodInfoManager">The method info manager to use.</param>
-            <param name="callExpressionParser">A parser to use to parse call expressions.</param>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallMatcher.Matches(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Matches the specified call against the expression.
-            </summary>
-            <param name="call">The call to match.</param>
-            <returns>True if the call is matched by the expression.</returns>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallMatcher.ToString">
-            <summary>
-            Gets a description of the call.
-            </summary>
-            <returns>Description of the call.</returns>
-        </member>
-        <member name="P:FakeItEasy.Expressions.ExpressionCallMatcher.DescriptionOfMatchingCall">
-            <summary>
-            Gets a human readable description of calls that will be matched by this
-            matcher.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionCallRule">
-            <summary>
-            An implementation of the <see cref="T:FakeItEasy.Core.IFakeObjectCallRule"/> interface that uses
-            expressions for evaluating if the rule is applicable to a specific call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallRule.#ctor(FakeItEasy.Expressions.ExpressionCallMatcher)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Expressions.ExpressionCallRule"/> class.
-            </summary>
-            <param name="expressionMatcher">The expression matcher to use.</param>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallRule.ToString">
-            <summary>
-            Returns a <see cref="T:System.String"/> that represents this instance.
-            </summary>
-            <returns>
-            A <see cref="T:System.String"/> that represents this instance.
-            </returns>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionCallRule.Factory">
-            <summary>
-            Handles the instantiation of ExpressionCallRule instance.
-            </summary>
-            <param name="callSpecification">An expression specifying the call.</param>
-            <returns>A rule instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionParser">
-            <summary>
-            Manages breaking call specification expression into their various parts.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Expressions.IExpressionParser">
-            <summary>
-            Manages breaking call specification expression into their various parts.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.IExpressionParser.GetFakeManagerCallIsMadeOn(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Gets the fake object an expression is called on.
-            </summary>
-            <param name="fakeObjectCall">The call expression.</param>
-            <returns>The FakeManager instance that manages the faked object the call is made on.</returns>
-            <exception cref="T:System.ArgumentNullException">The fakeObjectCall is null.</exception>
-            <exception cref="T:System.ArgumentException">The specified expression is not an expression where a call is made to a faked object.</exception>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionParser.GetFakeManagerCallIsMadeOn(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Gets the fake object an expression is called on.
-            </summary>
-            <param name="fakeObjectCall">The call expression.</param>
-            <returns>A FakeObject.</returns>
-            <exception cref="T:System.ArgumentNullException">The fakeObjectCall is null.</exception>
-            <exception cref="T:System.ArgumentException">The specified expression is not an expression where a call is made to a faked object.</exception>
-        </member>
-        <member name="T:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax">
-            <summary>
-            Provides extension methods for configuring and asserting on faked objects
-            without going through the static methods of the Fake-class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax.CallsTo``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <typeparam name="TFake">The type of fake object to configure.</typeparam>
-            <typeparam name="TMember">The type of the return value of the member.</typeparam>
-            <param name="fakedObject">The faked object to configure.</param>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax.CallsTo``1(``0,System.Linq.Expressions.Expression{System.Action{``0}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <typeparam name="TFake">The type of fake object to configure.</typeparam>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax.AnyCall``1(``0)">
-            <summary>
-            Configures the behavior of the fake object when a call is made to any method on the
-            object.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-            <param name="fakedObject">The faked object.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.ExtensionSyntax.Syntax">
-            <summary>
-            Provides an extension method for configuring fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Syntax.Configure``1(``0)">
-            <summary>
-            Gets an object that provides a fluent interface syntax for configuring
-            the fake object.
-            </summary>
-            <typeparam name="TFake">The type of the fake object.</typeparam>
-            <param name="fakedObject">The fake object to configure.</param>
-            <returns>A configuration object.</returns>
-            <exception cref="T:System.ArgumentNullException">The fakedObject was null.</exception>
-            <exception cref="T:System.ArgumentException">The object passed in is not a faked object.</exception>
-        </member>
-        <member name="T:FakeItEasy.Fake">
-            <summary>
-            Provides static methods for accessing fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Fake.GetFakeManager(System.Object)">
-            <summary>
-            Gets the fake object that manages the faked object.
-            </summary>
-            <param name="fakedObject">The faked object to get the manager object for.</param>
-            <returns>The fake object manager.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.CreateScope">
-            <summary>
-            Creates a new scope and sets it as the current scope. When inside a scope the
-            getting the calls made to a fake will return only the calls within that scope and when
-            asserting that calls were made, the calls must have been made within that scope.
-            </summary>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.CreateScope(FakeItEasy.Core.IFakeObjectContainer)">
-            <summary>
-            Creates a new scope and sets it as the current scope. When inside a scope the
-            getting the calls made to a fake will return only the calls within that scope and when
-            asserting that calls were made, the calls must have been made within that scope.
-            </summary>
-            <param name="container">The container to use within the specified scope.</param>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.Equals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are equal.
-            </summary>
-            <param name="objA">The first object to compare.</param>
-            <param name="objB">The second object to compare.</param>
-            <returns>True if the two objects are equal.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.ReferenceEquals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are the same reference.
-            </summary>
-            <param name="objA">The object A.</param>
-            <param name="objB">The object B.</param>
-            <returns>True if the objects are the same reference.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.GetCalls(System.Object)">
-            <summary>
-            Gets all the calls made to the specified fake object.
-            </summary>
-            <param name="fakedObject">The faked object.</param>
-            <returns>A collection containing the calls to the object.</returns>
-            <exception cref="T:System.ArgumentException">The object passed in is not a faked object.</exception>
-        </member>
-        <member name="M:FakeItEasy.Fake.ClearConfiguration(System.Object)">
-            <summary>
-            Clears the configuration of the faked object.
-            </summary>
-            <param name="fakedObject">The faked object to clear the configuration of.</param>
-        </member>
-        <member name="M:FakeItEasy.Fake.InitializeFixture(System.Object)">
-            <summary>
-            Sets a new fake to each property or field that is tagged with the FakeAttribute in the specified
-            fixture.
-            </summary>
-            <param name="fixture">The object to initialize.</param>
-        </member>
-        <member name="T:FakeItEasy.Fake`1">
-            <summary>
-            Represents a fake object that provides an API for configuring a faked object, exposed by the
-            FakedObject-property.
-            </summary>
-            <typeparam name="T">The type of the faked object.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Fake`1"/> class. 
-            Creates a new fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.#ctor(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{`0}})">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Fake`1"/> class. 
-            Creates a new fake object using the specified options.
-            </summary>
-            <param name="options">
-            Options used to create the fake object.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.CallsTo(System.Linq.Expressions.Expression{System.Action{`0}})">
-            <summary>
-            Configures calls to the specified member.
-            </summary>
-            <param name="callSpecification">An expression specifying the call to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.CallsTo``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-            Configures calls to the specified member.
-            </summary>
-            <typeparam name="TMember">The type of value the member returns.</typeparam>
-            <param name="callSpecification">An expression specifying the call to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.AnyCall">
-            <summary>
-            Configures any call to the fake object.
-            </summary>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="P:FakeItEasy.Fake`1.FakedObject">
-            <summary>
-            Gets the faked object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Fake`1.RecordedCalls">
-            <summary>
-            Gets all calls made to the faked object.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.FakeAttribute">
-            <summary>
-            Used to tag fields and properties that will be initialized through the
-            Fake.Initialize-method.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.FakeConfigurator`1">
-            <summary>
-            Provides the base implementation for the IFakeConfigurator-interface.
-            </summary>
-            <typeparam name="T">The type of fakes the configurator can configure.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.IFakeConfigurator">
-            <summary>
-            Provides configurations for fake objects of a specific type.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IFakeConfigurator.ConfigureFake(System.Object)">
-            <summary>
-            Applies the configuration for the specified fake object.
-            </summary>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="P:FakeItEasy.IFakeConfigurator.ForType">
-            <summary>
-            Gets the type the instance provides configuration for.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.FakeConfigurator`1.ConfigureFake(`0)">
-            <summary>
-            Configures the fake.
-            </summary>
-            <param name="fakeObject">The fake object.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeConfigurator`1.FakeItEasy#IFakeConfigurator#ConfigureFake(System.Object)">
-            <summary>
-            Applies the configuration for the specified fake object.
-            </summary>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeConfigurator`1.AssertThatFakeIsOfCorrectType(System.Object)">
-            <summary>
-            Asserts the type of the that fake is of correct.
-            </summary>
-            <param name="fakeObject">The fake object.</param>
-        </member>
-        <member name="P:FakeItEasy.FakeConfigurator`1.ForType">
-            <summary>
-            Gets the type the instance provides configuration for.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.FakeExtensions">
-            <summary>
-            Provides extension methods for fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Once(FakeItEasy.Configuration.IRepeatConfiguration)">
-            <summary>
-            Specifies NumberOfTimes(1) to the IRepeatConfiguration{TFake}.
-            </summary>
-            <param name="configuration">The configuration to set repeat 1 to.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Twice(FakeItEasy.Configuration.IRepeatConfiguration)">
-            <summary>
-            Specifies NumberOfTimes(2) to the IRepeatConfiguration{TFake}.
-            </summary>
-            <param name="configuration">The configuration to set repeat 2 to.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.WithAnyArguments``1(FakeItEasy.Configuration.IArgumentValidationConfiguration{``0})">
-            <summary>
-            Specifies that a call to the configured call should be applied no matter what arguments
-            are used in the call to the faked object.
-            </summary>
-            <typeparam name="TInterface">The type of the interface.</typeparam>
-            <param name="configuration">The configuration.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Matching``1(System.Collections.Generic.IEnumerable{FakeItEasy.Core.ICompletedFakeObjectCall},System.Linq.Expressions.Expression{System.Action{``0}})">
-            <summary>
-            Filters to contain only the calls that matches the call specification.
-            </summary>
-            <typeparam name="TFake">The type of fake the call is made on.</typeparam>
-            <param name="calls">The calls to filter.</param>
-            <param name="callSpecification">The call to match on.</param>
-            <returns>A collection of the calls that matches the call specification.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.MustHaveHappened(FakeItEasy.Configuration.IAssertConfiguration)">
-            <summary>
-            Asserts that the specified call must have happened once or more.
-            </summary>
-            <param name="configuration">The configuration to assert on.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.MustNotHaveHappened(FakeItEasy.Configuration.IAssertConfiguration)">
-            <summary>
-            Asserts that the specified has not happened.
-            </summary>
-            <param name="configuration">The configuration to assert on.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsNextFromSequence``1(FakeItEasy.Configuration.IReturnValueConfiguration{``0},``0[])">
-            <summary>
-            Configures the call to return the next value from the specified sequence each time it's called. Null will
-            be returned when all the values in the sequence has been returned.
-            </summary>
-            <typeparam name="T">
-            The type of return value.
-            </typeparam>
-            <param name="configuration">
-            The call configuration to extend.
-            </param>
-            <param name="values">
-            The values to return in sequence.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Returns``1(FakeItEasy.Configuration.IReturnValueConfiguration{``0},``0)">
-            <summary>
-            Specifies the value to return when the configured call is made.
-            </summary>
-            <typeparam name="T">The type of the return value.</typeparam>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="value">The value to return.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``1(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <typeparam name="T">The type of the return value.</typeparam>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``2(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``3(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``2,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``4(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``2,``3,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``5(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``2,``3,``4,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the faked method call.</typeparam>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Write``1(System.Collections.Generic.IEnumerable{``0},FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes the calls in the collection to the specified text writer.
-            </summary>
-            <typeparam name="T">The type of the calls.</typeparam>
-            <param name="calls">The calls to write.</param>
-            <param name="writer">The writer to write the calls to.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.WriteToConsole``1(System.Collections.Generic.IEnumerable{``0})">
-            <summary>
-            Writes all calls in the collection to the console.
-            </summary>
-            <typeparam name="T">The type of the calls.</typeparam>
-            <param name="calls">The calls to write.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.GetArgument``1(FakeItEasy.Core.IFakeObjectCall,System.Int32)">
-            <summary>
-            Gets the argument at the specified index in the arguments collection
-            for the call.
-            </summary>
-            <typeparam name="T">The type of the argument to get.</typeparam>
-            <param name="call">The call to get the argument from.</param>
-            <param name="argumentIndex">The index of the argument.</param>
-            <returns>The value of the argument with the specified index.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.GetArgument``1(FakeItEasy.Core.IFakeObjectCall,System.String)">
-            <summary>
-            Gets the argument with the specified name in the arguments collection
-            for the call.
-            </summary>
-            <typeparam name="T">The type of the argument to get.</typeparam>
-            <param name="call">The call to get the argument from.</param>
-            <param name="argumentName">The name of the argument.</param>
-            <returns>The value of the argument with the specified name.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Strict``1(FakeItEasy.Creation.IFakeOptionsBuilder{``0})">
-            <summary>
-            Makes the fake strict, this means that any call to the fake
-            that has not been explicitly configured will throw an exception.
-            </summary>
-            <typeparam name="T">The type of fake object.</typeparam>
-            <param name="options">The configuration.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Where``1(FakeItEasy.Configuration.IWhereConfiguration{``0},System.Linq.Expressions.Expression{System.Func{FakeItEasy.Core.IFakeObjectCall,System.Boolean}})">
-            <summary>
-            Applies a predicate to constrain which calls will be considered for interception.
-            </summary>
-            <typeparam name="T">
-            The return type of the where method.
-            </typeparam>
-            <param name="configuration">
-            The configuration object to extend.
-            </param>
-            <param name="predicate">
-            A predicate for a fake object call.
-            </param>
-            to the output.
-            <returns>
-            The configuration object.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``1(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action)">
-            <summary>
-            Executes the specified action when a matching call is being made. This overload can also be used to fake calls with arguments when they don't need to be accessed.
-            </summary>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action"/> to invoke.</param>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``2(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`1"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``3(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1,``2})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`2"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``4(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1,``2,``3})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`3"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``5(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1,``2,``3,``4})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`4"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Exception)">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exception">The exception to throw when a call that matches is invoked.</param>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``1(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``2(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,``1,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``3(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,``1,``2,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``4(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,``1,``2,``3,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``1(FakeItEasy.Configuration.IExceptionThrowerConfiguration)">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <typeparam name="T">The type of exception to throw.</typeparam>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Guard">
-            <summary>
-            Provides methods for guarding method arguments.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Guard.AgainstNull(System.Object,System.String)">
-            <summary>
-            Throws an exception if the specified argument is null.
-            </summary>
-            <param name="argument">The argument.</param>
-            <param name="argumentName">Name of the argument.</param>
-            <exception cref="T:System.ArgumentNullException">The specified argument was null.</exception>
-        </member>
-        <member name="T:FakeItEasy.Guard.ValidatedNotNullAttribute">
-            <summary>
-            When applied to a parameter, this attribute provides an indication to code analysis that the argument has been null checked.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Helpers.GetValueProducedByExpression(System.Linq.Expressions.Expression)">
-            <summary>
-            Gets the value produced by the specified expression when compiled and invoked.
-            </summary>
-            <param name="expression">The expression to get the value from.</param>
-            <returns>The value produced by the expression.</returns>
-        </member>
-        <member name="T:FakeItEasy.IFileSystem">
-            <summary>
-            Provides access to the file system.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IFileSystem.Open(System.String,System.IO.FileMode)">
-            <summary>
-            Opens the specified file in the specified mode.
-            </summary>
-            <param name="fileName">The full path and name of the file to open.</param>
-            <param name="mode">The mode to open the file in.</param>
-            <returns>A stream for reading and writing the file.</returns>
-        </member>
-        <member name="M:FakeItEasy.IFileSystem.FileExists(System.String)">
-            <summary>
-            Gets a value indicating whether the specified file exists.
-            </summary>
-            <param name="fileName">The path and name of the file to check.</param>
-            <returns>True if the file exists.</returns>
-        </member>
-        <member name="M:FakeItEasy.IFileSystem.Create(System.String)">
-            <summary>
-            Creates a file with the specified name.
-            </summary>
-            <param name="fileName">The name of the file to create.</param>
-        </member>
-        <member name="T:FakeItEasy.IoC.DictionaryContainer">
-            <summary>
-            A simple implementation of an IoC container.
-            </summary>
-        </member>
-        <member name="F:FakeItEasy.IoC.DictionaryContainer.registeredServices">
-            <summary>
-            The dictionary that stores the registered services.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.IoC.DictionaryContainer"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.Resolve(System.Type)">
-            <summary>
-            Resolves an instance of the specified component type.
-            </summary>
-            <param name="componentType">Type of the component.</param>
-            <returns>An instance of the component type.</returns>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.Register``1(System.Func{FakeItEasy.IoC.DictionaryContainer,``0})">
-            <summary>
-            Registers the specified resolver.
-            </summary>
-            <typeparam name="T">The type of component to register.</typeparam>
-            <param name="resolver">The resolver.</param>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.RegisterSingleton``1(System.Func{FakeItEasy.IoC.DictionaryContainer,``0})">
-            <summary>
-            Registers the specified resolver as a singleton.
-            </summary>
-            <typeparam name="T">The type of component to register.</typeparam>
-            <param name="resolver">The resolver.</param>
-        </member>
-        <member name="T:FakeItEasy.IRepeatSpecification">
-            <summary>
-            Provides properties and methods to specify repeat.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IRepeatSpecification.Times(System.Int32)">
-            <summary>
-            Specifies the number of times as repeat.
-            </summary>
-            <param name="numberOfTimes">The number of times expected.</param>
-            <returns>A Repeated instance.</returns>
-        </member>
-        <member name="P:FakeItEasy.IRepeatSpecification.Once">
-            <summary>
-            Specifies once as the repeat.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.IRepeatSpecification.Twice">
-            <summary>
-            Specifies twice as the repeat.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.NextCall">
-            <summary>
-            Lets you specify options for the next call to a fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.NextCall.To``1(``0)">
-            <summary>
-            Specifies options for the next call to the specified fake object. The next call will
-            be recorded as a call configuration.
-            </summary>
-            <typeparam name="TFake">The type of the faked object.</typeparam>
-            <param name="fake">The faked object to configure.</param>
-            <returns>A call configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.OrderedAssertion">
-            <summary>
-            Provides functionality for making ordered assertions on fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.OrderedAssertion.OrderedAssertions(System.Collections.Generic.IEnumerable{FakeItEasy.Core.ICompletedFakeObjectCall})">
-            <summary>
-            Creates a scope that changes the behavior on asserts so that all asserts within
-            the scope must be to calls in the specified collection of calls. Calls must have happened
-            in the order that the asserts are specified or the asserts will fail.
-            </summary>
-            <param name="calls">The calls to assert among.</param>
-            <returns>A disposable used to close the scope.</returns>
-        </member>
-        <member name="T:FakeItEasy.OutputWriter">
-            <summary>
-            Provides static methods for the IOutputWriter-interface.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.OutputWriter.WriteLine(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a new line to the writer.
-            </summary>
-            <param name="writer">The writer to write to.</param>
-            <returns>The writer.</returns>
-        </member>
-        <member name="M:FakeItEasy.OutputWriter.Write(FakeItEasy.IOutputWriter,System.String,System.Object[])">
-            <summary>
-            Writes the format string to the writer.
-            </summary>
-            <param name="writer">The writer to write to.</param>
-            <param name="format">The format string to write.</param>
-            <param name="args">Replacements for the format string.</param>
-            <returns>The writer.</returns>
-        </member>
-        <member name="M:FakeItEasy.OutputWriter.Write(FakeItEasy.IOutputWriter,System.Object)">
-            <summary>
-            Writes the specified object to the writer (using the ToString-method of the object).
-            </summary>
-            <param name="writer">The writer to write to.</param>
-            <param name="value">The value to write to the writer.</param>
-            <returns>The writer.</returns>
-        </member>
-        <member name="T:FakeItEasy.Raise">
-            <summary>
-            Allows the developer to raise an event on a faked object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Raise.With``1(System.Object,``0)">
-            <summary>
-            Raises an event on a faked object by attaching the event handler produced by the method
-            to the event that is to be raised.
-            </summary>
-            <typeparam name="TEventArgs">The type of the event args.</typeparam>
-            <param name="sender">The sender of the event.</param>
-            <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
-            <returns>A Raise(TEventArgs)-object that exposes the event handler to attach.</returns>
-        </member>
-        <member name="M:FakeItEasy.Raise.With``1(``0)">
-            <summary>
-            Raises an event on a faked object by attaching the event handler produced by the method
-            to the event that is to be raised.
-            </summary>
-            <typeparam name="TEventArgs">The type of the event arguments.</typeparam>
-            <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
-            <returns>
-            A Raise(TEventArgs)-object that exposes the event handler to attach.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Raise.WithEmpty">
-            <summary>
-            Raises an event with empty event arguments on a faked object by attaching the event handler produced by the method
-            to the event that is to be raised.
-            </summary>
-            <returns>
-            A Raise(TEventArgs)-object that exposes the event handler to attach.
-            </returns>
-        </member>
-        <member name="T:FakeItEasy.Raise`1">
-            <summary>
-            A class exposing an event handler to attach to an event of a faked object
-            in order to raise that event.
-            </summary>
-            <typeparam name="TEventArgs">The type of the event args.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Raise`1.Now(System.Object,`0)">
-            <summary>
-            Register this event handler to an event on a faked object in order to raise that event.
-            </summary>
-            <param name="sender">The sender of the event.</param>
-            <param name="e">Event args for the event.</param>
-        </member>
-        <member name="P:FakeItEasy.Raise`1.Go">
-            <summary>
-            Gets a generic event handler to attach to the event to raise.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Recorders">
-            <summary>
-            Provides methods for creating recorders for self initializing fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Recorders.FileRecorder(System.String)">
-            <summary>
-            Gets a recorder that records to and loads calls from the specified file.
-            </summary>
-            <param name="fileName">The file to use for recording.</param>
-            <returns>A recorder instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.Repeated">
-            <summary>
-            Provides syntax for specifying the number of times a call must have been repeated when asserting on 
-            fake object calls.
-            </summary>
-            <example><code>A.CallTo(() => foo.Bar()).Assert(Happened.Once.Exactly);</code></example>
-        </member>
-        <member name="M:FakeItEasy.Repeated.Like(System.Linq.Expressions.Expression{System.Func{System.Int32,System.Boolean}})">
-            <summary>
-            Specifies that a call must have been repeated a number of times
-            that is validated by the specified repeatValidation argument.
-            </summary>
-            <param name="repeatValidation">A predicate that specifies the number of times
-            a call must have been made.</param>
-            <returns>A Repeated-instance.</returns>
-        </member>
-        <member name="M:FakeItEasy.Repeated.Matches(System.Int32)">
-            <summary>
-            When implemented gets a value indicating if the repeat is matched
-            by the Happened-instance.
-            </summary>
-            <param name="repeat">The repeat of a call.</param>
-            <returns>True if the repeat is a match.</returns>
-        </member>
-        <member name="P:FakeItEasy.Repeated.Never">
-            <summary>
-            Asserts that a call has not happened at all.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Repeated.Exactly">
-            <summary>
-            The call must have happened exactly the number of times that is specified in the next step.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Repeated.AtLeast">
-            <summary>
-            The call must have happened any number of times greater than or equal to the number of times that is specified
-            in the next step.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Repeated.NoMoreThan">
-            <summary>
-            The call must have happened any number of times less than or equal to the number of times that is specified
-            in the next step.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.RootModule">
-            <summary>
-            Handles the registration of root dependencies in an IoC-container.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.RootModule.RegisterDependencies(FakeItEasy.IoC.DictionaryContainer)">
-            <summary>
-            Registers the dependencies.
-            </summary>
-            <param name="container">The container to register the dependencies in.</param>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.CallData">
-            <summary>
-            DTO for recorded calls.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.CallData.#ctor(System.Reflection.MethodInfo,System.Collections.Generic.IEnumerable{System.Object},System.Object)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.CallData"/> class.
-            </summary>
-            <param name="method">The method.</param>
-            <param name="outputArguments">The output arguments.</param>
-            <param name="returnValue">The return value.</param>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.CallData.Method">
-            <summary>
-            Gets the method that was called.
-            </summary>
-            <value>The method.</value>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.CallData.OutputArguments">
-            <summary>
-            Gets the output arguments of the call.
-            </summary>
-            <value>The output arguments.</value>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.CallData.ReturnValue">
-            <summary>
-            Gets the return value of the call.
-            </summary>
-            <value>The return value.</value>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.ICallStorage">
-            <summary>
-            Represents storage for recorded calls for self initializing
-            fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ICallStorage.Load">
-            <summary>
-            Loads the recorded calls for the specified recording.
-            </summary>
-            <returns>The recorded calls for the recording with the specified id.</returns>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ICallStorage.Save(System.Collections.Generic.IEnumerable{FakeItEasy.SelfInitializedFakes.CallData})">
-            <summary>
-            Saves the specified calls as the recording with the specified id,
-            overwriting any previous recording.
-            </summary>
-            <param name="calls">The calls to save.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.FileStorage.#ctor(System.String,FakeItEasy.IFileSystem)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.FileStorage"/> class.
-            </summary>
-            <param name="fileName">Name of the file.</param>
-            <param name="fileSystem">The file system.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.FileStorage.Load">
-            <summary>
-            Loads the recorded calls for the specified recording.
-            </summary>
-            <returns>
-            The recorded calls for the recording with the specified id.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.FileStorage.Save(System.Collections.Generic.IEnumerable{FakeItEasy.SelfInitializedFakes.CallData})">
-            <summary>
-            Saves the specified calls as the recording with the specified id,
-            overwriting any previous recording.
-            </summary>
-            <param name="calls">The calls to save.</param>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.FileStorage.Factory">
-            <summary>
-            A factory responsible for creating instances of FileStorage.
-            </summary>
-            <param name="fileName">The file name of the storage.</param>
-            <returns>A FileStorage instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder">
-            <summary>
-            An interface for recorders that provides stored responses for self initializing fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder.ApplyNext(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies the call if the call has been recorded.
-            </summary>
-            <param name="fakeObjectCall">The call to apply to from recording.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder.RecordCall(FakeItEasy.Core.ICompletedFakeObjectCall)">
-            <summary>
-            Records the specified call.
-            </summary>
-            <param name="fakeObjectCall">The call to record.</param>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder.IsRecording">
-            <summary>
-            Gets a value indicating whether the recorder is currently recording.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.RecordingException">
-            <summary>
-            An exception that can be thrown when recording for self initialized
-            fakes fails or when playback fails.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
-            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
-            <exception cref="T:System.ArgumentNullException">
-            The <paramref name="info"/> parameter is null.
-            </exception>
-            <exception cref="T:System.Runtime.Serialization.SerializationException">
-            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
-            </exception>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.RecordingManager">
-            <summary>
-            Manages the applying of recorded calls and recording of new calls when
-            using self initialized fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.#ctor(FakeItEasy.SelfInitializedFakes.ICallStorage)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingManager"/> class.
-            </summary>
-            <param name="storage">The storage.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.ApplyNext(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies the call if the call has been recorded.
-            </summary>
-            <param name="fakeObjectCall">The call to apply to from recording.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.RecordCall(FakeItEasy.Core.ICompletedFakeObjectCall)">
-            <summary>
-            Records the specified call.
-            </summary>
-            <param name="fakeObjectCall">The call to record.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.Dispose">
-            <summary>
-            Saves all recorded calls to the storage.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.RecordingManager.IsRecording">
-            <summary>
-            Gets a value indicating whether the recorder is currently recording.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.RecordingManager.Factory">
-            <summary>
-            Represents a factory responsible for creating recording manager
-            instances.
-            </summary>
-            <param name="storage">The storage the manager should use.</param>
-            <returns>A RecordingManager instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.SelfInitializationRule">
-            <summary>
-            A call rule use for self initializing fakes, delegates call to
-            be applied by the recorder.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.#ctor(FakeItEasy.Core.IFakeObjectCallRule,FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.SelfInitializationRule"/> class.
-            </summary>
-            <param name="wrappedRule">The wrapped rule.</param>
-            <param name="recorder">The recorder.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets whether this interceptor is applicable to the specified
-            call, if true is returned the Apply-method of the interceptor will
-            be called.
-            </summary>
-            <param name="fakeObjectCall">The call to check for applicability.</param>
-            <returns>True if the interceptor is applicable.</returns>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.Apply(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies an action to the call, might set a return value or throw
-            an exception.
-            </summary>
-            <param name="fakeObjectCall">The call to apply the interceptor to.</param>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.NumberOfTimesToCall">
-            <summary>
-            Gets the number of times this call rule is valid, if it's set
-            to null its infinitely valid.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.SmellyAttribute">
-            <summary>
-            An attribute that can be applied to code that should be fixed because there's a
-            code smell.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.SmellyAttribute.Description">
-            <summary>
-            Gets or sets the description of the smell.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.UnderTestAttribute">
-            <summary>
-            Used to tag fields and properties that will be initialized as a SUT through the Fake.Initialize-method.
-            </summary>
-        </member>
-    </members>
-</doc>
diff --git a/dep/FakeItEasy.1.15.0/lib/net40/FakeItEasy.dll b/dep/FakeItEasy.1.15.0/lib/net40/FakeItEasy.dll
deleted file mode 100644
index 4f27c109966fa5f8bd78d182be4f33537b775c90..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 646656
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%0AHo4@`U6S)TPPd{x>jLH_~Aq-_uS
z6x6#h?Nu#N)u;V47OqeZXjFfP*21RxuW6Ixs6SM{S}Rlbi5@7|nOLngDN}oQrd4YP
z$@Y23Pf2@2J3{5{fp9!5rpWdRZMj~PlHSxJ*f+!Xr@g5~D*Nmia3UN{d38Q6Osmm`
zbNR){FH760#VQ9hn!oSV8rU>{e@mM-RW7ew6r%i!w70bcwp{PW)7}YgA9*})OnX<$
zQh8dRZEz`BJcIJDrtQ-DOr!Q*gWraSD*Lt1V1HVjR>b}VZcKY$>o%RrM`1gBnf8G;
zlzqAKN7^d(wQyV7$6C}3DnDQO6D{&S@?*-MYFpUv!at^cuGO(Whks3L(puTy!GERg
z(IVqzedl~^*7_(r<6W~hK-rmJG;2fIG{5*t8?NlsZ_#2yT(YP|t59~X@84>DW(xe2
zi$Ab@eer*_tXa}jzxU$rwF<I03;Sun;vckzko*B}yVj!Y%m)u>N69?@JD?q7)BNv8
zEq1nA9*^HYY5B^uyb+6k(khhceA||KQ0p~EmUqs-4lSQe=i6^ug>t#*kN(9j{$1P7
zj)QMod=y{9R?8Eq@QlTOYf<b<*t7UwZ34RnUb0x|`Ru*$^2M6o#Qp((bg`xPnn&&Z
z1wXeqOpj*w#&P%3;#2gA%CtUXyr=4Ol>IzDbkj?@{1B9{U3{8u-!I$q33=T67f0yB
zm8t&j#i#38WZQ%M0#8ppUpWv)<5f?+f=$=sp86VPpS=v_<GelfO`NCeb1%J$^F_#i
zvACCB!+E-1pP@I9HM;(up*OPWdVPl8%BJh}8F~ksuJ65dks#N{d7cod+se-S!bm+r
z*?C_WsZVCp`@%>)o=xuyBlQG!CHi}J(ph>A`*ZdxwuSRp=BwBju<O~^vt{qlKWhQp
zviL0BvAjR{@8YwAUV{ADi=u)qgnwFmp5Ch3qy6*y;=a0=FIxy`)LyhcfKBaPq)%g0
zd;Ro8Hnn$&zDn6AD$u^MWI%9vvi_+{E)QC^AGPF)pm)dO{sHdwfLuQHXV1bxdbDyt
zqxysOIczF_rC!CR_J-&U%H{Z`6s}K8hUgvaUGNu)Lxaov3cg{<RVVoNCBuUL9r;;H
zt`7P*oU~+k(2*E7moFI+^o4NAl52t<3_rQ#+Mr|LvlqqaM^t}k{WdMRUN2oB*EgV1
zK31<*_K7=D{^cd3^cMDFc&Fz^{UEzowKrN%P3+oU)k|*H*C_kd_NrfUs~+Q#`Ev0(
z%73xsc6|-|W4LX}1YIOi{zv%Gk~{S>WuI{2I`HR`yY(9OEwGh-uU?f*<(I%`q)*kW
z+2!!X>C^Oj_I6o*(R96uy%%1aGDB}+pNi|m!1Vj{{mQgGIuqmdD6ee4(!K%tq3Q8@
zv~r<+3p^<)ULU}o4j=Hw>%-Y8@HOc(^;mW}91D+QzXXp-pQTS^e+=IN$FmQ>|4o{$
zC$PigF@H{<t*5dF!?V)o=vnMr;Uu_-JsVz{K36YeXTb%qP(Oa_F}N&!p1y|iYCdr&
zdA?p9;={=g=tEOv1==1@rYGv@WP3B}$9a<U9A%&V5j-6(<@_OdQc|*B!Fhq}-~n&4
zzMk_v;SK3teG})egg3+6Ie#a-z>}iaaDE<qC^<#1=loK*EpegV$S#F<dKT&}Y<ix&
zNZ-$<=gEuo4)$7<kMpGJN7*mJ(_wQVR+rbeGcir?M&{?+X?hG>j`vmRY5Hik9PeL)
zC$Opii}lHD>i=SW4w>(#mgtGf<zgq6|91KkJv}6Uz?-fYasBU*pOloLmnr+~U*QAZ
z41EpfjahPgW$GK10~*cuGWG4s&h=uc-ffXwKWBcpG<ZCmi~9cbEIo?z<Yl^78P5xm
z|0F$IH&bPOyib6e)0gY{>`8E2dXC<p?3_P7y@~USkpD5=r?;{ng^#7@=||YFsC>RI
z(y0B<RlZQ~rA+O0%UGdDEBm$IknfpMq)*`TVVKuMWvtXEvxmT!WEAV^>|2#f^i}K!
z;6WLs`g(RAe09cydaW|97x48N59v{hWq*948XlAJu%53>{h5$arnf5l!#+oTfu}-m
zr}8$<7b^4)Hq93*^kY<BJ#W`MkLhEV$o8H6Q>kw!Ys*H-_mP$QLFIDsE836GcwFzF
zPW`bl5A&z3)`zn%fKxNp==JOvcxlF3y_r2;d7U1cA?ufm6gW5IDSaIKN%)bBr}cPc
zTEC|<p3$?Eo%f*|^ipM?{T|9co3TN!V1Eri1+S;_{JvwOzKKoivr(^BcHW=<N0+^k
z^Mzkge@n)*dcDfi@?Xt(PH$Gm{g}#c3YPDNd1Fn+X1!0QtWV|N%XnTNN4C#Hexmn9
zeWJ3@z5<Se<2fG-Pf6RVCvZLvj)zk@zYzW+W1F7E`4ad$xQO!`VZ5)>H?rk;Febf9
zZ&EH7uOR<pMwQ;8Tq)%Hyk9e3((R?PzvQsYSM;H5`9ANQ%vbe^?DtXs!pt3dzA~*}
zXX0ymX^5}Ld`;h??APdh#2b1&`%~0^JoQbzImBz>BkXUGkIAgjqqAgx{8|7$;N7WD
zR4x>MD!--U6}!yy_buMmTb0YjshDSv$*k3nP<bBD-qDY7{#xYk$b3idwoKM97x%)G
zGvC#Fu~Xpq%w2jkneSKX^f}7(e94nprzf)I^QA>_s&bxq4)vp!yvN7GF1K{c;`j7Y
zm3O``;@2ybo$cq>H!1JZsk~o5!tKfD#hID!>qE0;fAhpPw3nG#?;LO8@4&ZvKM4B6
z6KyrYMVTMy@v8o#_E+%3nIGy2%9Z$w8~FYRT%lYp+?dxto%xa8z#ar|&TP=_<+Q!V
z!{Nyv>wVbs;2oJC>qE)By>{!<IKLA4U75Rs{p&tbULQYkY{~oA1Kv+`uPX0+f4A|3
z{MMvKJxk@=v`Vyh!27AbM%gFcQT|LnqU>zn&z<`G{o$b1{C`r?=lZb|miM`C=g9SI
z)4oG{GB1U{2c*hxh9h&NyV~!gTq)eRFKEpCTp!2o4u6x`q!)#_J#&v<$L_82%{qo|
z{8Wkyl)utr*q6b-XSV2x>=Ce7`i;JwJqA8)>34buTi!=CX13`OxzwJzk6QX)eKPw2
zRe!&}p1lY@e`!E(VaxZcmoIJCBlD=f^o>h@(x-)Z%F<u-EVjH4Te$RBy;`|kJPJR!
z^oU-^UJq9+?bMstFT!h<{;s#M-&OfP^n>iLRQ;p6nJ<@Lj^7xT_5aj+DOZZ4@Y75G
z(g(5S^RMTZ{;f|8@s6ec>RDu4$9+}pQeot?yTN|AiXF*rVMnv=0$Tqea0ALq;mCE%
z?cwukMuf^c`(HOAmCMC&ly6z88-3WfDx1atw!9B)S?V%|D_4pX_`gf#-y)Phek&V3
zurw^_JovYzrv@#bcO6RZW_Y>2eBXL>X}D3tehB4{FYRu$vp2$5XPjn47RvVV{tiC6
zG{P9i{sOkLdKl~32b51YHYq#fQBR{P#D|i58Z{w4oZQQ(SElXpXY!dwlX9gnaNl-H
zR;1C+ww2E^j<LJLJ+jU=qE^WMRf_ZBbF<Dd;@R^1D<iVbHFDVfkspzDp0SD@1K*H!
zzR}K}2#?R|YeW}Od-D6y)3Po!ydh4`y2#iP;{2?BMtg|YWL;uJuk5P7BkM9Fo-L2J
z&$0#@>)F$=yw<EMj2iX=_@}HvMstWev#vCbv6mo!JZq>ix|rIR-#6^B>?&goTYkUi
zl4VyL%^|*e*$AUo36+=mTb5mGObGFeW!D*{Ax>L%gHg|x-!FP-*+|1IrTWsVmfdK?
zhWOcKHyK$Wer?$pqdLSNExW}y65_UHw;6*T>}v1NW#f$r%H<*(>!)YmZmeg&3V)e)
zr;-1VEMG1HaP8u|jcT@7fae?86O9^nZ@6dnJ;o9CMesS<_Zs41sy_t&ci|+%W-m~l
zY(%g(z|q-pMjvH5elN|QV&sJQs_bb-nKIokUza_@*hqQ14)p_xGmI+sZumyztJ$sa
zZE&4(K$Gu(CS>1dG%Gvrf9^9{sk}IV@{^J82=RT{@kV5sT%SB~2>E&0GmSpV<svK*
z^K*EzvQL~1r)AGFsyTld9GyMes8y~Mqu|W!IYuMp?c3p;?0H5D=jD8>5I)G3^R3CL
z_Zvq;JOj4NWq&Hg_p$Q#eG-gb?1Rb=7=74sKK5XCqA`dq=VPm~Jw_~B&c{||Cm9pi
zap=$5>||qFh@a0+F%sA_kl&HL&`4Ky=5Gs)Rh6<o&iJ#)Sg%|z5>Wo_>_x^Vw*3BV
zeRir*&CWyq)9f^(nJvFh`&IU0qn$0kPrEOBiP7tE*?zf@-=960oo+<2*P(uAc7_ql
zejWZdJJXoMZi3y*mm2BpU*L%4Sw<226c66#E?;J>VP6DausqwSWsig}TfW?=XHSQR
zF3&NJuruK6mivrj?8o4nm**PYR#AUng6~+KXAEb53{PI3Z;WLhfM+f*FxIfGBq1JH
zUTAD#_k|ZNUt!d;uY<Fe7a5K0IJjW>N~4*b20ygC*l1^$!;dd7F*?{U!t0lp8j-81
ze;>e`mp^FqVSf+5y!;_!C|gU$_d}LHY{an7g+EwcW{hKxfInMaZcJp~1Ao2z5n~!V
z1>V2>QNzoA5I(fL!pLFE??3O#e9S0gZ$|$2<(0-Nb{%{SUaw5YmzDFl(M0C^;U|n1
zW#{?%6Gl7dTTy>Z`jbWn=a0a5z{faG&*Rq^<`Z&z_-xxN=cn>-Wyv4E6$$sqSsV1Z
z@HudVDo_2nIA@*FpX*<Me4J;!5u+T?sQ!9mBAe>3H|9`zF<7<tv{AzzrIz=M(d$XM
zd>`&L<@>*9oaKklSM3LFWx%$l%X#qSIU9_js=jkRZZu*-d?<ONF*d}9lmBB(RCeYA
z&l&L{`Kxj^8`a8zFk1feMy;~XehAB(?s?v5pu9%?dBNzjMr}Wh`m@DIWz+lk7mY2-
z`2Hd4$K<?d^ja&+<Nj88n=y{v0N<SRl2OMFz<1`nYz$vV<$s4~=e%OnDEmZIirikW
z8ZDf^240-=s<EFv7G9pS!#K)LfQxfpGsIKWUJ?9QPPNgCEuR~%&w1U5Ql{<sLe3k;
zP-W-+S&cE8%<s=?jEQV|f40-uqFgCj(cbo)w~QLLd~Wz=POVYTJ_7H}dDn<tFZ+Z0
z6Fg`8G3PxafgK53zW0q5c0V}6_n|TNX(~SwKGXM+(V<)}<a5I)UxRU!eLsAe?_)ze
zBg^CZugdQ>Z1y_kPmBoVLVkbMXhgDKLH<y3qY+K!`}0qY0m_wP7xLHmJ~h&n%Y`4l
z(f66LhTR0;;cGH#+3j$=Z;#QWOxrg#V~-KFLH5r%e)k#!$oAhTKhL+<7^>{E-FS|e
znz7f2J)wNFF*d}BzGfqy>-R+Y%}HMw3G6<yzV9o;tL!{4`^so$%j@fhp0A7n8)bj|
zf_^{nYa?Bm`j_bY+9)I2m#g-_F;=nfQ0;$Xtmpdlecf*i`#;nkwf~JVjZN);Yiv?>
z+W*$5C9C)Oo0D3NdiHeHeyh>Q^{M?<WB9Y7?YA1GY-+#FXjXRGZ!<c`cB1P4KI14m
zOSQkx5YJJ2)c!srfldA2XVkE%{r!f$NtSoo-*5CGtM4mpP6`<P*{f9h0b`J|v;70c
zDmJwrFb=Y*{U40sn?u|G!I(g{pI7}qU`%Gy_Bmk0D?9BUFzVUV{sANEd0Ibe|3@Q1
znfjmM`_U*O+cjuE-}jSI&Gy5^u&gbw7oWiuT@L>Se#&>y$%oT?waapTx;Z5OBg${{
z9dgQBzrmZ6ehK<7c!#gc|H3uCj$q!xbMH~!!$Eh0I}?8k`t%bWegPck3FgDEgaaYv
zN5h+a!Mt_1@{wSBv*FIf&Y-;~c^SJtWP8f;jmpmbc(8tWG0N}qb@@^F1Grh0ZwuQ9
z$9X!97Pfp3Anj~_6VKT{LHX7bmM8yLp8WBLha(?I4BF}g@A3U^w4YS|m~tS@DQ~_Y
z>lfM=q5LTC??!~OU!(eeIPF`*k#F(+Vf3Q%JU;$y3<&W7-`~cZ5dY#kW>hHC_V~m1
zud$Kx_AO{{r{}m)t=y(fQtb<~NjXnE3xDV_%?@Q;KjD9UmMMEHkH?)V?>6(dNYnA$
znP{68%0Bx8<lEpiY+9aeZaSfSm{~=(_o959C(Nv7e-BTG>)5}k{3&JwTVE{mr<l!T
z-X5o#t;zw7w%4iVu@myAndXbKzm=i~>brAKbJi#P95~Js;n=zu?o13i{Bk%Vx69Wm
z_c)>a=A_euz76@_xm~_nxo0ph$A=4Ydj&1WhXJ`~1})F`t8ydF7}ei^`o8Q1xo4Z}
z*|Plgxlv|KhzI1JYc?piX*00At8&jbTa=ys(>K`uM&xhGJ<;QHFAV12M1Fei#X*0d
zd`ZyFa6;|?bH8feIo}4E$3mQzJIIXKDz|sOE#EW6c?O%2?B8X3aI~^tqyAiJ4hr%3
z+@WT#ZL)rwW-gKax!UZbT&Ge0t}&xIKSAZMGY4^=`WtJ;aDFZF3As0#<2X<KA7f5d
z_KBa6&&s{c%wl)KdAZ}vQsr{-FI=2EKDhq!`CHVIJ5F%R;uBqwJK==<+T1%&@Uyvh
zpWv5sCpr#4HC=A6dxP$Mk}o>RvGDY+^43)N#<WRJeM|l-V`pNQb53;lLvWlYm=9lb
zqOBL<(DvkeyU_N&J<;KZPpluVXUP6_wSPJs=b0Sr-+Aymxj}~ygg?lQ3+7|s&$}Fc
z3;b2?6ek~k7u?!qYbqQF@hteKT=_TI<&WP=f`84O9`sW9zU&!6KM4PxdtcD2;eT>x
z2K^lD%9|7Pt8n+cc|m^w=jA4x;4|~)2i=H#)RF}!xMlGIGqOtdFQ8HVL^C?XXXbg#
zvX>}N^^?s_A#PcmY(~FKc{)D5=FkwgEcTkCLtK%YVkU%mZSF#|Da6m_rkeXh{BmxZ
z8TpEApT?7m@|HOL=lzjxu2K0w810XAbEC4)-i!6UC@<ZtqP#}?C&TPe_G`3%GR<+@
zssFS;vdk<t?XP8Kt+HRE{gZ9Zd6ml3{>d@7uxbC~nf4CK)BY(iCn)>X^Q{j(E6fHq
z&CiO=aj(hp`9hArory)JSuI^ITG9Ujc|~Trav+S(&tkJexzPR@`RSfwvx@U{zLuEH
zY&u^{%vLs?uO;R|_Ft$U=P5O}ye^j)(CkdP{8F=(eLB15P0F9kUSC7Lh`otDgk8m^
z@u1YKX4803YSy!9JSa7rmGi|&)c-xV)QsIJ+s_ww!&m1$WG1lXd+FG`a<i1Z5FVTN
zs9CQZ2+N1>$g42Tw^aYaRx3Yd#<E|6@6D?;v)Jz`KW<jDX*^nG)+!g;^1bwQ&nmNl
z^E5uKHusY?8lP612iY_}tu~LbX?$93c6*!F=SSII-fD9)TU(0zzq~c(st_Mae#&fQ
z_eMTBZ@qbheHomYx5136rS+rnZi5-krtxlrIfzZ;-A1#BJr?yBcs82d-l6((z8=Wk
zXjYRo8V~<t)^VQ3!)MKA&eM4Kta(hiK-`7)IuoBWQ{R>C;rDUioV@4EboK-Aio8u`
zK090GH=Apeec}<gBJX)~3+JDOpUiu~tl|6{@H2T^%zF06@aDW1%_c7YExcywR<o7;
zi}E&Sd{Fb@s=TV8<@mKL@0FmBqx`(=SIvW}en6A=BMo`4nn&1lzwuhIynLVfq31R8
z80Y2l_s{aGO>-A*&+b|Be5!WJho8sp#`%G8Gs^cOYx4f)fVbL=;`}g`e?3@V?w@b-
zx-9Rf8uH#Sqq)8uulMEEm;<;z-H*Lx4psJtja18j%N)*@-&>fJ^p+W;?7S~{%N(uj
z%%|Qm$0^fz`%~Uq<}|8r)B3z^CXxkhkGIWy&QpJD%{n&q_Z_oUxm?Kc*UH*u9#gIq
zGtr+v^6E^pPHsP1-YNO-nNehWvFdNV8O_dP4>+NGy*c`X@*kPwPALD8Igwq4`f;9*
z%xUZ=;pwnky1buy7VeSX5OlRF-{tpC^5-Xc-$~Y&$>nv`k37i(PVxx2cgXT@h0hJ~
zH2A_0%kO<$nE$cUU%tQI9rSYKFU{|AK73_<V=(`q@~1(shDYRo7W4+VGqK4`sFT~r
zna?+wSs}hLzsW2M@%a2N%qp_I74;|Q?=h>D17Wm%_n5V8I$rmfjmm9dH7FnF*<-e{
zJJ}uVbF(Qg-jn@l3%i*e!A^%KCG9c$C<nr5|LrjcDHqxsk)MwCV>wUzbFVpp^Dn9V
zUNfHaw11mTFX!J@`DQbR{RtfB`O++7|ETg`n(LL@!mQ;o|CL$AzJp!Meumx1KFDrm
z56z+a9qcr?cm7u<9^I++e*-=jjv(XD$jbfwmDz_q0=_c8#T>+5to)4`%iaNx$p6-y
zz&-+ZCbpXK%7yljTzr2vzt!}zM=H0OIm&@BIv)RPma*x0+-I(5)AOMHW)+*B2YqkW
zDz}B*h4yaC{=sZyr@|vr+s#%gugURchwn$TgYsG>@*jGBGR6CH{R3JxJU{=S8KK;!
z)xyd7hs-{lm*Zn<{?Fzh&bJ}IFR#Ol<-8ofv+@s{6F5)5KX=%S=R7^HI&6B`?mYE8
z%FJQ+Q2xy<W6SHu)}$lmdgV4vevc(NztgPZynMd3&G)-m%lWI2ACY?0Y~=hss=dF=
zR<^u8?C||<c5wL_$RF_Hf120R`qTC4A2UL^P-G+DnfQ;{hh3`L`^S`}<^4w`yu<fz
z(9ggH`NxCa3U5u)ET{bI@Pqk!(DHjV75Qe+pQyY$=r7^5`C&m*|4s>-p4WA`4du5c
zo#;g0sn#Iszk0s1F+bc&r1cG>@uItx#isG3yOl%bZF+v$-6~?!^UChlM&-7!Ls(v%
zr@OU@eMLTb3){=CV$=EB-P+Ek^R>HG&8G9UyH&%c^R>HG%ck?SyH&@g^R>HG&)&|<
zYhZuRZe*WPK>cfCk7YNri`gygUF=r&U+n$tOAF=r(cNli&w$T`53*^z>TY$gX}s-j
z9bwaW+}%3Lrt!MFb&O5pad%66AdjH7FdC1$Tc)y~&*$z|FUs@ze3})l?3~XLRs!eg
zeC}bTbDqxU)2;2Cr}Md&RmXWcpU<@RbDqxUGp&P^52NwuOzRk%#-rX=w-2emG#;I0
zMX_l-I@=ncTqxx6y)8e=8cuobQEb1p`R7_S%5@r@Pv=>+oc{v(g8V*K1Lx`dxxm`b
z`3qOb^XVe1LmA)K#`v%~slOHVk?N0zKXrubS$}JQa-nzv_IdkTqm}&{jX#%I)7UgV
zU25g9>G}F)R+(~}wjTAjCJnIGuxWf6Xl+*xXf!@uZuM!P<<s~y$Qq<vr_uOvr8SiE
zyV2eb-w-R7^E6%zwI*{usz{C>!>l>Vel_3S;Tvw1ah}Gr5!QOn)A)CdRl}z7<65hQ
z%g;x9or%|42bJqI8n3Rkj&lAL<nj0OEc0X8|2mDvr|YZ;<u?2~BiWxDtSIF`7~TJl
zv}(zG|2xuZWz+rcNUMWQ_roKtKD%Z60gdi=M_T>abU!@O8l>zK<FLG~Nh7Ta_AKR5
z)_!(6{CfV4*0@h(dp_|H{7(K&Rw{cH{6YR0tA_nNyu){k71Joo<M$!pPxEiJyvok?
z_%>?`o36*>tajx(tr6wF${%k<d@Aebi*Mn!{M)So><+jyae_5gxzHBHa{QTKO(cuc
zVVR%9?!);_%556WHzrtH*aMNjGXGAiicRy6yR7Z(IF-NKs%F#tWujHfE<*m&{Cll>
zHqBQiTaD~0<VWOBv6|U5f0<^rvcEwdf6u{cSEl*v#{6lP`I%gQzq)_f;hS#tQVwXR
zmf-rDKf{V<pQ(JGHI#j!a=bN~Jydz7HIY3=d6qSYEx#vsAb+-%s_YX};LgN3R+F+{
z(D^&ZGC!yO(D^#o>Z4pI=zN=J4Pw*ya=$f^%hUW|zU5`p`SXBP%BJ&Yfwf*4fBy{2
z-<H3?I>Js?PPE20$>j&MOl6Oi$}Un)vZ|Dw`@>|bI>fzmlPy_W-apa%46n7H^7!3X
z`98vHi7#ZnO<RNZdgrEC-IVcsN97k<V>#cf@{6pA$^lKj580fQYE^T-cd6Wdsl2>8
zYaIMreyUYR<-_QGNtz}0$mIpX=zYmzD@M6ao22S5vAoK3Jp7fv#3~}&vycxf$gs-T
z9yryPVXaaQXf$8Ru(l{W&+{^^8qR+oi{Gy+SZW>RJU!pbvik3p{c(POI?LH!Ryx|h
zprFeul(U2R$KlHga)REVoEvl%Jft8$=(m&$tXQ=?=kHMzT4R+18ZEETN@dgXimdf)
zT3)eL!=~kxTFq=)-a}S9o0j*mbyV3|zp`L|K1P48Dd@6X-l&2{g84T1mVye$;XlI@
z3Ldv2n&tMQ{c|r|p&SUK{1et1%G-aS{Op1!tc{$f`Qa1RcCtqAub;4LIZxOBC#_yz
z%Ju_cbp2mrHIn)IyUrT)mCCE<K|6fwtXMX^pMJ_3r;OjXd=U2^1y5TC**)Ntf{j+p
z*RsA(oCn8wHd*781M2!W%Dc&`V$=D#*&5J7%cJ@6W~)jWf3FVnjjV#rmiY~}clKaB
zPb+xd8pj@p_8%^I!P=x;E{4HR6l}E`l=1ff7s>ba+pI=5y&vCZwX*5`_%^G9tkL`N
zZI<~h^@rY%S6Pv4dO!Y>HGoa;$6vBy*z|t<rQrUg_upL}gZ}OEb@^_%Eiq{8KKSW^
zpu-d4I8T=|Pjc}|u7Ib9l$U=mVu9!7V1L#je<-=jo8SeWSAzK}ctSy!--Nex+4>NE
zImCP6*9*2g^{xGIAa_U5zbd~LwD}OO?*-M4!+XK_dlrtZOW^u~F3a!NO(>`d=0_p_
zNr=b8dkc03^V8r!L9OHP2jGKUwidyMLoB~vU>4Rn<t;iM-wQeu<xef_av|I!#FZy`
zBOK>>&l;<a2fAMLMtQHYKa8#q?^~&C+W+rcS#<n_(e{7e%4gH|f8Q$Q^0YqhTV={^
z+KX7;(*^HatCZ{1^`bNJeQOQpdt-c%-pKXo`tZKBiA~psdS`w4`t?E3^7z@D^ntZS
zm3P+X1FKq@#;3l8A6ZA017Wm3cU$5+dH%G8$?uU5EZl8Huy1}C<24+u><^>!W4AS$
zP3OmMYaE-7|J~L!HXZ-Ftwg6jj;}b+ZYz~d$Nz3ChfT--CsrAoj{i@rS~ea3jaH*_
zK%?WY(TZuM^Pi6QPp$QAI^I9CYL$KBKUkmF3!1EHZL+*i?0`oU?y=S@2Q)e#_F7eJ
zIv<*?S~i^zUs}hw{(Gn&Ti9Yv{I6`!uhH?}Vog>KXmtFySaaBP{C{J4*>wE3S~+Yw
zep{^yHXXmM)+RO`zpYjco6e6`>xi;nqw{0G)oq{bPoek@{To>Lz12$@f3GoB9$(*E
z<CJ~k2jrzUvj1SWQhoJ2<7U(!zF)Q%(CB>m!Ae#339C%*&mXK(c29N(I~tx)_=6Ss
zy{zvOS1Pw#(aL^7+v|W8t6ZqwH%=-%VC^UK_f>wf4k|m>>z}NnA^DkwKUsqU)c!SS
ze@MY0E0KL8yrA%BtCl?x&M54#B7UIqb75cMVQU<F30zj#Y1Jqfibvp41;1NI*>b-7
zWZ_Y3O}ngLC{`o?pTc8S!~ybi@Jofqtt|Eq_>Dr{wTA77-z_v<Wk1sL_rkjiZC3;P
z7x>G<Q(fslQG2*$68j3nU5&~<A?F{53VXO>4pRLH<o_t_>B?uH1OHpt%T>dUhEH7)
z>1t-n`OldvqFm-7sy|rOKhIUc9trnZalT9ZO!@Kfz!ev`nv~1MY<T#Ji(KX}GLPRk
zhWn-UbM;{_SNZ;~Qg%5UyW&z;t#YA|^ZD^B2DsWgsQx<SC$1RiiuhHTfB*4v*8t^8
zu@(6#D=v4%u(!iAS6ty5$9_ZQ2fL=R<@|5viYr}-%FgjJ)FoS&&lBHA`S~ll+^jsz
zRj10+_}G~^+|}){EKlQS%8KExXytP86UwKr7~zUlE)+*$-->Ho+m-#wMJuj#)hpxt
zcm%%>u;Mybuiw=2#o2Hm_d3^bHjOveyQV1zH0s|Ct_C*sZ=|dL5m~=nT#EXuR@~^C
zrtA~f!_Ta^*|m!E6X7W<ZgDkpem1;i#jUPm?8VCCTmw2~dp`R?_~jM1yQV4o?R9XR
z=XO^-S-c2WBR_{-3%|YM4p*vjp=gBPTXCmrBfACOy<(!PNjad&{N5FlT>IHF|Luy&
zt|KA!zh4pOGJlu-DHJmQ%ZjP4Udlev4*$7gx+|W26m}O)cWqJj3;R*rzrZc*Nch~M
z`&<!!sPz;5ReqLhEIUT!=eTl|1KI@mk|O-OR`uf#p9C-P;NP5)Ee|}XsLPAsVIeMn
zuP>S(EME!#wiN%?k?Yg?<KGamY5fy}rsaDahtvEbDd-o`-mOJlu7L-IxE{ve>j;+L
zd!j8l|DMoQ-jeh0`-&Dh<*gr3-dmIr^gnQVQD)Hc`+<c;*+F-&z_$X6@`8?r*B2GI
z%GCCx^QEe2rAr)@D;x-;^(k@L%7r$~7fM_aoTv3GaYeFe{YqSYl=JPY(f;d2C9VNn
z|3(<!|8T`9`@<%(W4S(Uk5bnJE<cO&@tmjaQ|j_keJus~>1eNr%8NYZ2VLtq|CsVa
zu4?usxHIu#SB-MMsDcL-J?!dG_KBVF>u|R}<@)=zdbqxz%r%-#+qc}cUOAxA{&~!0
z|0T=&#8)U^Tl9o0UfHj{pIKP6&b5h6`)`A5<KI+Xem|h0XtS$DIiS)0*y5UeOy={&
z4`^>sQI#wDA8Efv`}-BwAmx1V5Axok?XEeTKl?Gce_wSavIi=^=1OPN{(s$-qfFyv
zRneQSQpyY3o;zJ-Y-;Z<*Lr1VJg#-slf@{s-&R!XYEpLYpLe<TD?9hke%DcDI=(s+
z{m$_heh2CwDuVx2>lZc|j`R3kCRw{5{!Ql9k6)b+zZHEDwA`LzWrM4mDqks*Q9fej
zr>-bvXL+BwqNzQbmiL*fKbw~KnbThQBGhk7{LD3g@`9HCnQJ&(?(g4<zHp6Irv3d}
zQM0Rx^VFZOUHy;C4m-<lbq!MX+thxmD@NJbo~^F2%FgqXR@VeBPyKCmO(Y9ieygj9
zP0QQoYE*XGYY(muov&S{^SR3<Sl`H%L0fXZblyq6WaW>p7S(>GcpT-2tUTznZ#@P7
zlK6AbTa<qZx(2>}WryQ%xxAZJ{_0pQ@3xbC@5<j?rqF`hud1liH6X<CEB|oiD+l;~
z<}cSO<+iZ*(f%&qU#|63-nJ|8`+zI|a#eG_H+&OZL-jSezPG{6A-;FzG1n30I&B)t
zdsqJJiq&L)d}5CBaaR>PQ(3s%*(J)FyN@o*Q~j5h=<dnN`Qk<74<#G!M0TyR>CRF1
zi9PU=m6p4j^WVe1mA1Q;Z9I;@XR$KOU24eo{es4`Q{9`C@%NvR?@T<^eT028{KU#r
z-H9gke>(j1%5LsW><3i&2zR6<^Um=T;Rf(W0O)+)y3(;<TZZ!6SDwy!zm^Zbz4DBp
z%ivE|o~^9rYjfrMh;!W0s(orNer1%~tBm;)@_SdF@7@&RZ&&tlS1UW~*Vo;^rtz<@
zyNONX(*^E>%1-~I-Mw6Debo5${mN)}A7y9x{oJFKY5BjdywvSg_Vf66nLCwD*N*}2
zbT%!2pgV_6%fH;cicRC~AoqG@r$1M^>&dD=M^|3yZc?WHR25z2ZVhq#%B$T6mHmR+
zzs5btP5YbLk8#JaX*|E)ouKS2FV<Z~R?9PsW8G_%o%O%by-AtYKce_%cQ2dTr{igi
zJBCfyt1<2@Hm(17_ZBww?{;^yQy%AEWzht8yE6VC2i&{(E_Vl8jt{+y?{*($%kkm7
z;)!k%7JB^M<L*yZ{lB>Q9`{gXXMCLO9;fWLY5p+TJ%KE!f0Nyl+0?%{cRZW6-&A)3
zo3`I{w^!NOe)qYvl%4s|eeMqBwy-B~eDCtjbRT7Z2S=`)={~0Hv-_=**RPrGUZ=?Q
z!T-x*$12nIzOs0xyFSEwSIlxZhxpqSv)%2=&hbCT9djz}ADWNMaZhB^d}OXWRoN$Q
z$MVvP=DRD{vz0yW?QHpcVMK9?yPfOP{BWT=q8qhO+i!_GmQC9)-R))5_RDnVuxa~c
zxvP`|YCJt}WwyIdxNMJn$;uq}SY>DX=DNLPwSQxabKP0WbbJmeC~&V2@wnnb_ZDT^
z|MwIZx$7t|mSX+xD=u+2g_OUypwzuz*_nSl>^>TjUr_w8dt7(fKU!XDak+b%av+SZ
zmlf_gY`R`nxD%D>`j=H);jRd&-<eqHwojAowT02~Q0b0PE)?>4!;0cc_gH0T`#kQR
z9O6q>u68G|<@X65Dt^+PqwIWN@=14*va|i3bPqqhtN*J|z9PgMi`TiUl%4D226r`^
z)^CHmmQCxo!CkNH%vUzJ8<qV$U)tbqV$*zSgS(l`^P>&!V{DqAJnJ6aQ})j<XnwNU
z9n(u1e;*(FYisdVcRZP&7gV_um7V2Rxl@&$<yX1W*|hvBcNUqKU*+Dyrscol-p{7x
z?{H_Gp_b3fd(&N{?2IRGy33TE<-O^yAoG0dO?Nw++I!1A@yyWncDdt~>3G`d+2zhs
zcG|0R=a9L*I(I9Z+I!#KzjtVR4en{m&h}_<&rx>TYj7u!xxEJWdN#H9iTj|kbG$UU
zk19LuHMvEkT%OZjliMV7drj_cY-(?>J4)GUuf^S8*=euEJ&4Nl@zUZR%Jpe~w7AEf
zQ2#sk#1ra&=bpy(X@2~jJK?1Asmio{cNBl;F6HtxKW=lEk-7hE?oDj!|9*F!a=9qS
z@mF7bz}?9H5By2-kM0&SA0I!t*PNsFhZ>*u6#wMj$bJ*$zbQWGu2QD{>@Pm#ZYSIF
zeP2iM&+a42`L=xDm+1S&ZAZ!We4-xpJBojGPhdB}e-s~f_dl2NKfuR}kGS*M^7mVg
z7ys_=AoKIoqwa?Dsehd)AF=YNySlG3_y13KopPmct;X|~l0V&zA?{gn%-#P2S-w)7
zg?vt)uw&R4!55Th_C)qz__7lGIb-&9@Kq(Ioy8st$COxh1^aIJCOj_K#Gawb+jb3m
zK72<>nBBxqh3_pn#cpRWhi8;@vm-8~{*}XtCE<1-_7iZoMcwVm>}Qovv&+~ua7syp
zU90@4_!#b&*28X6c8=fEZ8JJ_d!23%Rjw5OMfoKqr`tvBLvT(>PrHSE6fQ0~!#={+
zp1`P9a;81tqR{pt?R@1*aVqkwOCs$uc2D@}lC$hJZ23Oog_3jZCiXeVZ!bB|j<}fC
zzaRW&$@z8+dyvZav9pw&@usicpd1LJ`>P9VyPvF2*PptQ3+x2;HK^a27;UHbmwCD#
z-L^8?E(-CzD=)TJDHn?IDBn=h-`>J`d42jEu2XidPyOu{WoP^Lw~r`4D(*r3Z&3ai
zdzSJgwt0zM{-Yud-dA#|-Hlzy?!|somA}-EVn3sNnH|gCt~|h=!`=h8mkhK^**~lN
z<@Oe~@ucj}6?OwVQhAVlkbM#SOUYon&!yDAA@DvpmOYvs&z`}~VW+d#vmasCvR`Dk
zvOj=3(SGD*w7eF$z2r(emVHoph@HT8t&#m7Y8SC1;e91n*_+sxu<O~^vD?`b;D1m)
zasVxF7HpLcvt!xm@HZt_+t@ky@mnilJWmh$VR%SEmn&6%L@+PMtDT-M%ja7=J=X;D
z^7}*hK3&l3RsC!2IcoWIJcpNFYd0zTZF+xugWW=Tdn?Mvd2X=VIZyMK8|-ca<@)$-
zdcS#tJ)BMRog3_FY<j<WgPp~u_nSA^>z(>|o+R6^X4Cu48|->Ez2A(r_p|B!W~|-8
zruUm8ZToW7A3^W)M%sOpo%e5}>?~zGZ&d3u%3i~k&l}=AqwH4phnz3HLbg|@ea3E3
z#`AS{2j~A`4;UoN`@|V*slAEp0q}%EET4U?@{M*ATmIdcb4y3tt?Y@)H`xc-ad4dH
zW_$Et*?vHy<KbqzM%gE3BHx)f#%^FQV#i!b<>`1CV{c*8@ioS-Q^x=6;quMwwd@Y|
ztL#2QWP5&_-mj0br?Kh%`dE9Fvh)3`TkLAGpx<}D#f};(>lca-(cVtaE%tC_yzfxQ
z>#cT?vQK=D{1Yp0v%6g-%j5l>@;JLpnf|}bPS1F|o%6pUA6<I8J$e|GKdwB%E@Pjz
z4u4;$^e(%d-50*5bfO)5HI=^#eq!alc0BuL_~z0{_D1D^M(0bMUBjmHDb5}=oa#?P
z`MXNv>{#|(<tcWevh%)ns$IePG~@>sPPHRPQ2j!<GjXatfc-c-R@oWfr`qF`>3oeV
zooahSJiBzd-KtzC<lifr?uoY}uc7ugsrF{tqm>Ko9Wd^f?FpQJkMjx2`F1mWYT-;f
zUD<E%gA+?<+7;|y;XvX{dn5aAcp>uJl?!eADQZ9BTDg3`E&mRYTwWh`G`s*F#J++(
zfqfl2Q5pBw>@xN&c0HG;@nNRj%uYvMF0Y+k0?Ym$Wv}D<b`16Jc{m;Yk0gs~uHT<6
z-^a`LhO>8aek}Vl_GESd{%z?@J0ZkdR?M=~*}tpubL=9v{QgCD=^T4ihy%HE?M)%h
zE1hRov*~?kf?dxJTQ85F`F1nAH@icbj+Y??^X-W1<of<UY~6ia6xI3w@Y%wex80rH
zp`v@eWkyLwM)%^4ij0bq$_k4T3yac<a#yf0snA$Or37Ua5fl&=STrgtGb&6fBugwR
zD=SJVA}qO~VNp^2p7T7<z|iN%e_x*SHfLteyzH47Yx{UmPDcl%e?j^u3unm%WcfU>
zXNga4Vqe1UV_yfJ=J&~i>~yv~5w|zl&kjeo%8!GCg+4ifEIkFD4*8R8KIZewsq9LK
zuPOA)KK2&y`ocMK4>}+<f$Ivh<&?{D{h{Ig^l~n{4dTKz=zw$({CweDSx%tzKVo?~
zauWOa4I=&HayA;qZ*X1V<8nX8W5K<dxpL$cls^IdX5oA}g`Et3yKsSA$bJCR=gCd%
z9Pr-4fIP@v1pc@%Uyi@hA;JD3t-$n4WuMJ^3k&21bU-SDcwON#xu4?=n7&Ysyo&O_
z3@%t&B&V@I#P|xikbMAMEH|M8(vRRT3xjfeq66#y9em7JBImIk8_8SQv^|x`eQf&u
zy+qEqTI3H%UQEAQE?}Pt?kij^SJ?bZVX5527RR5y!ZNuH9h71qy`!jH-p9TMy;kmE
zr=!=&U2O55E=N&?e3-o$T`BjoE74W*Ai7lA0+x%`%lb8<y`|DNu(xP~9Kqg&-Y7@1
z_oFw-G3>+W8abZ*2l&*YT6r>CJg;(QQAiG-B+94#tzhY9Ig%{X`1Z6M&DJ-G@$YFl
z7Hz$s>uEU&-R<}`0gewvPs?c>7k<~@Am^Y<<$po`*rI3T0`@uR=j00X66qrF#G>cr
z2G0NRRieHZWGRW3KMCSj7rh|op{?V~i*hlV?$1mvdQq-M!|@jK-%_+qmaY}~seQK>
zy(CXYTlrs>eQ4|ZJ1@)G=q0k4&o{H^WjUAP@-0yRgWv*=r-A1bHOj>te-JzmT*2`i
zjK3o9X4CQK6}g?$FNXM)S+B?)9A5#3?+wd`DK4!C!}o>dK{nlQe^m~@4%Zj{{=A^*
zRXHAQEzfImGTK_6*W^@6FVpesH94K)@>VFnH}f^w$8lQUO>#EJU&DBloX2rG|J@-M
zaQq#JPxtSTOE~@+c$)upxtiU}Ze)w&-OQrb<#x_5&W9facX0eSNWZvfr`*Ny6Kml6
zH{d>whl3XvHOm7WKMUi{a@h6QAM$^}D~sNcW6%L<5_p>b4LP4Z9Xu1_9q6}?r~Z6H
z&YmptzjeI$J%0hj2hdi3zA5WBh`80CZ_43lYx{Up9!+uHKHik0IQ}ryH>c<=IS&2S
zaa8_Wax%s7{!B$ti=2g~`(vAmcF6_kZU@arX_bq~3e8t(m8&^U^G{mkt!$dF^0wT}
zruizn<#sgf-&=~_kq?vQJZRsGMSJA18^!W<D>Q#~j~vdX>!Uq#B%7{}_Q<hpx}Mr2
zC$s7LYmc1Hrt7CYau%DmpFMIOo90LFk&D@M{j^6eW7GLjn_SPP>!&ukkxkc6d*$71
znxDH@-p{7_xqIavHqC$CD-V!)KIvXrz6qD#LG!!clOx!4{{NmFMds%>-jn0lbp7zY
zoW$vAK5Dz1%BK0KAIKSOI{thl=dfwM={~uDP4i7Zmdn^Q|8l?F%%<z1{c;<du7~!^
z``L7TwO>BWrumki$<fKQd^A7xGdZ43^HV>UC$njO>X&jFo93H-DQB_i`m|HdW7GWA
zujOJk&0qamu4dEx)vx8PXzTjvYq^Evbp8L0+{UKssV=#l&GT2~gKWBf`Bv^?)Ah}_
zau1re?^lYxm7}JJ<)!06b5XaPgof*V*xtK+-^s~rdLH9DIUT)3u7WtsZ<Vt+F20ZY
zpC#YP`4pF^zrT}<DK7E+Sotu=Y5jaBOE-)9TP3mozFqX4ETgG?3&0T+m$yKDv-~~s
z7*0>;$31ca$7z1vAvu}jG(Yc<oX)2CdEd)fY?=>uSk7b9e7PUxVsxpr6YASrbVP1o
ze+2%d=&0Pn{s#S%+`;|@{AE$UtluJ*2ksBo3LlfB*ao<}=w~^ZeLA?e=oh&L9hAm_
z`-=wTKK6y+KZ|~oGg3r(LFrPkzWfilk9{rpU&|%MxRv7KJ)Qqrew-4+o`numeC!42
z6O<<Qa<r_3-A4I0qg7=xy9GRMxvn&__o3a2JeAUa1)i|ntN7T5Fn_qx#vTMGEI(Q4
zW1mn5&j&4!P~=p~?*iYl{2xjLneVTUR<b!R=08neK3d6Ti{A%kfb-Eb{yzXNL(}&1
z$nw*b9<()of2`7nhWAUX5ZmWiMVcn+x90PYRU*)>c>Z#D@mOUHndiTZRT9`Vo{v?M
z*fd^`RZ`hBUXN8Wto(StYpjyRrtx~LlFO#?`b?#eP2=^MN)wyL>qw;y-R+?9GE#}T
zU9`X3LF46FN;2A-zduen$fo)G=O|HkP<k3q&sE~sG@hQPB(Z5cjaHi3^!&gDN_3jY
zZ_VG2QDV^6{QVduo=xN9g-Q~e#>ZGCl}+PgtWu1&=HtgHHEbFmFIKj(X?(m`X<^g&
zc(JmNP2=6gN*9{e|H9=LD<#vhy?lRjqEdlg!uK~PD%;o*u>DQ*PgGhsJsqDXDm`pE
zo=;T5?xgZ){ZCY)*tGs9DoJcw{}UA-n~v8Lm3%g>|A|Too7Vs3%2qb5|I3voHm&~z
zWgl6h<4J;Y7;W9}yh2I2OSCT_#o+Q>q3mai{cZK~E0pkbipOL8DrF41+d<>=RZ1+I
z#^bA$Bu;-dq(A1nN=awm%+6&`2X{k!E9a-<=~c?;yQ#nE{$Zk$%BJK0)k+E4x_@|$
zvW?9553f;1-y`x{$G>ZoIJ9;DaFPO_RLAX~j)zG~JvtzX=lPELu2o`Y(DL4k?Y&mX
zV*A)V?73jil53UlnUsDRxN`ZmN)r2Ewea;yE_*e`Z&0?f>(MtUhuKZw(DErt*1c5T
zyBJSVwz5A4!}}GLsQak>bUdD_B(UjtJyi+2U&O8ZiBpvrbU>o}g;SM8_F*h<s*;Yj
zw*OS61#PY0>57~|_0jQnx{`wqNVGjnR|?s`LV45t)0O?4p4R7dCFKFiPus_xN)Fmu
zKX)p59H;ehmr}r{^OJO?m`%%fw^GKY<-c30MqA5!w*m_<mVcC(fAhlfVT<y2F27G{
z#`Ltja6e3GxB2G62b2Mu_bh)<iFpv)&(Ev*l*w#*{?w<WpcnD;r#>YO-RU?!B<k}i
z`D}V0YNpbT4oFE5|9JTvC2f`{AD#yXA6WjdlEI#h&W86?P<$bH(Zab(xR1OBd?@P?
zC64_xrk|&jp@Y&+aQE^YWgEKF@g8{VqDPfJw!2>RPp*>e7v)*+-wh}Y=%92b#Cw-7
zR$9;jDFd9mc&RdaHr1cap2=PaKDK<RvYQ<QAGczeQkF^StHJt;A|*a+*r%=tDqGni
z{rDB7O41yPKM%fqMY&Rf4oc17Nh{VW)$9+@>y!p|7rH`eM0YyqdA~}f1>Mcp6P1ee
zkSO1J9=uA4M_c2`dL<1VkOrW<$t%_?Guhf^INw;YLD|awC-}}4HHz`DD6i9TKKPQw
z^-2yq0KRhZ7Nvmw0r=X*4N3*NRT=~Hy*>#%r&Ob9ezb4Jb4r8F53kq??}ZlSmr7!O
z+2bo-P}<Q;q|>&*_ON1`5;a%EX?tF_V!P5lkCu;)M~%vU^b&l(@tPHl%0aexpRsU{
z6^H#rxR3MG@vBh@%c1h<_|>RHpso45jmjAG5}B@-8<i;bxzN6=7Bnhx>_qT-C_jl!
z&m%M{$!xkFZd6jyoeIqdZdB6PG=Hm6NvHG@U5_^^S?t@O{Mr?-C^cyKel`4Fm-XbU
ziu9;xKlz1uuPFxF`hC4giMIK+Ctp{RY(DMDW+m6=bDn%tsYb)^X;9y@D_WE`_QT*~
zzFo@X$8dc}bbnx%B0Wx~`va{?6gnV11?gW}@wVb))As(3lE<!q_|6sYDh=qMv<+PG
z_#R~+y9K;!MVlh$it?@dC+{f$_@no=zqex8ZIJ$5f4dTn>6gf~em+nl$<hIc?_cqO
z5{vG1`~rS&#fM4~`--PU{(VXgrRVuBA1lphtNxFbHgu`93eq1~@v*X>T?Ib6;!`DN
zzG!c$B;H4NeDP;WJi89!X7LwF5?g$4F0%MbB^@1*pM`j*?<*yT{W`cCT+H4Jp635b
zso?zIfX^%bO6j9Gw)a292bIwaMEwEj2*l%yzgA+OAdB>qi@THx_MhNGfo~NfkK$?r
z?El5xN*4PR@G)PHGQd6uyu;t4L<dCrpmYUz+}uOTOf-D&1bln(_ewU$r-Sb={y`~Z
zXMrCrKCG0G`Ff^TsYcWOonPFmY(=-?`zfZ*{!wXUFM|AsvVK%r$oxHrKBbNQZGu>T
zeM$$K%6qE#h%!i)mP7v4#YdHhg`)jSq*dT`#Xl)YXu7|fncuJEu|;_sijOHBXlwod
zqV!RI-adX&q(xXB`pT?d6vO7HiU*X@HiwFTRT9zN{C=<Bl~gp$?}heE^Z%}-aa_DV
z^Tp!dl@hjiUuF}yhE4Omepi~=G~a7b=^{H$ct*TG=TAk-7wzkGc)`1h|57HS;r$rk
z4~r!=gDvLQd{KOyTEOY)eNxA%#T*y+_kV!+VYZlG>I;Oa#$qZzAIkf!_yjcyP49o$
z9yn1=<oLH(zpQ3+oUTt4wE!KE&W;!NuNAcky+pe9S+V`8YS|J|zBOM`Rjbj~`cl<;
zbf;q)q~B1isoU6#!He^q>TY%u_<?-4x*uIC4}eb$8tOr`wSEotFxonQGSq%bFO7N*
z&W9mAGzR`!@%`5kL5~`_6xYA(hWIppxEjYE4W163%%=P0C#flHx?g^hnvU*toCE12
zf+wrFY&w5ARW%Ak`PTdPPgCR3R{O@Pi8k->k5yC1@`F%br|(QP4IPlhd)IgP&r~yP
z>0v&Wnr-uRf25kv`IkfbY5ud+Le5_Xo(?Xvr9YH)w%THMV4S*-^KXRo_brH0J2-y>
z_)s89?Xjir%{)gPu=&j3xoY^6)SufS{Ve}^>S%O8ejVJKd7c`Dw)!htjiL0sKVG25
z+1#6Xfto~?Td}+tHJQB+%ZpLd&{laDsy<u(f~B!){)qU0)iQK9zHep1!i&`!TY8vZ
zq&9Gz&d)DZ2S>yc)Uc<-@>$zkf*Ovt)@On`+U6bp1a-2_hqA6v)5!AI(Ed)}mFi4%
zK>h)|!+)ik#c^@{JazU}Y7WQ6_4A>utJHjSw}aZ3s5Ta2d!&BIKW^@|YCrq<t?+zn
z@H%z$3W}THxZn+HH2YlewZR+JSTwc2VChY28d<&q;<Nly)S2jjJQ>`ZIYrIl_*9JF
ztmbh1K8)Y2=A%0uwEf?rHd0)g3-Q~7scK}gz5i}kC!?+YyIoBq%LR~rM(}oZCc6~;
zX5sB>7TPNR4z(mG%CoKy($yC9Dyat2-yfW*Cao0lCA>WMsmW|wp8M1^w3YvUH5(m}
zwnF~Q;4HO^()0G|9~wWz`+DXD{pw+i)Alqkn5hnoNIyrFR#E$Ce3+v~qpju5R%2~0
zSemU)Cd(~Q|1|$2Y6^QVcse+pE#_-Z^UqT=*q>m0o|?_3-)D2wTy#MG8sfc~IcfpN
zX*_#WE#^3lXOF5C6vyT5&3sI4x4B^H<7#9H_2*Ae-r>db)oAu#>{zz;ylCHiHJ%*-
zo(@hzTl2pcSpCW0pBeU9kp7*(0yP=aw<@vVyx;;gm3;-c+qXcS$-aRND;xe=M~Uan
zmO}b0j9dF_K+Qu_|E~%L)H1R>4f0n87pc|kd)f8qR(_xKBDIms?~`7nc5qxA&%auf
zuS%;$|Fq)#?Y2dWRRc}+Z3-?`$Dq6U`!)q?6q)zu0yUpa*Iz|e|BQMV+EcP{q$?LL
z9}(XYEFR(Q!Br!?GgvahyMv`8{6TQdkQYFGp9jlF`0L=>5$+9Es0G|!YG0LFZFA+q
z^=gC7TY?+ZM)VR%q#p>@sO>hNu(DR|x24}645?wIqCdMGBK^)_y&7)w?%)<R+U5^}
zPpcVhYX388w#{D$pH=g0?hS5L3(*0o2+BWc<qK-l8c|<BssV2azN8*R2c?(6XRd5i
zBg#ZPD7^z7zw%Xe5FL=d0AIYaNsV7i@m}zxl{?ik_6aY*{fU*$YCro7@a-$#RCCu+
zdhs2K`&aH#53;WV&sq7l8dE{>bnxRV-%)cb$vNn~YH}617`$xd2Wr@QatOSB<vulv
z{W7>=<;Utl_B-HLR(`5V)grw$9_?4hpo7xq5N}?&UyWk_0v<Q_Gc}IP=l`Fp=^KXg
zzrFHvwF|vSHeQ7HH~79%53|RB@9}@74p4eI23#3Dph_D>{(yWr_|ugKR2{uUz7hP@
z%7bb+$ESn4z+*V>1OKqHQ;p(y4)_Q-mgD*0ft6pY@f=?b{tKMMadG@Qan(0!GRMX7
z%LJ!!ybjWjS=FV^WWNPI8=S>H2tI$+w`vaiC-8s3`Ro(6!Tpw1-D)BGRB!^gj2#W0
zwCX#xfh=7Po&xUT_)Xx-V2>KMiPq<R;M7$;YA!nm{NSqZ)gGIlSoMRNUxVqb>oc_k
zP3w2vs$R8^%;z7+)B&`0{&7qVtHt#x7eM))zMoYc9gx?7cldu+BRKvn_`U_dsAD+Z
z1U?k_MUCb-t)BrkmgBU32Gj(OQ~&>}CUKnl|5r7I<L^RwZ>{=GP2>0h@Vnp)j??=6
zUCrV+t>53(T#i%!4XPDnsUPxxwQ^7mtE2uL^%7h^tr}GG(eOTM*k3;n{;8I*M??IZ
zRe!0?=zw${_?XY3Ng?bXIzFy)Xi@dT-3ooL<9KZ*d)H&)`yF9gHJiSFF-qIYrte>j
z(wf=y{fiT{b~b(g;sh;vGnFrnFWn1I&{D|!{fiT|9FEiXFJ!HN<MjOtSu1AK_dgY_
z1|5_xf#vymm7;B9UjshAMAe$n0qJJ&DJ8mgkmGlP&n|IleH?!f{7Sw{)3=EB1*Av7
z-3twEG&(3P0arZk(I5zat)t$%QG7qjJLFP`Pbe`*IKCu&$l`k)ix!@&MPYfg{a#aY
ziWY~qj>i#NJeiNj5n3w8>3Dpq=3|TN>$XMz&}z`7(t4=>hLX`*1KJw@{-rhBd|S!C
zwD6~g*Y}~o=~|4<ca@CMdeGMKe5`hu;&LsNKg&N>(;G0qydB)>8>>aL-v-}bGFFR4
z2jqQVKRAKoo#1KyGqog+{{o&4PT{z7yBHrLwLCUm??q|_Y`Wfy)JoW=Kzg_y)GFAK
zV7MOC>e&}!{A_J2`+AI@tu?Xl1>d(|oYsO4$aBGm0^_uHjxPphmqcm%IlczGDHx@7
zah&$Yb2Q@_>JKq~JXUg!7KvUYZ-(^w;AoET1TP0qX1@<E1N+!tfH#5**<w6s05`D3
z_^}<_hVI7iDMbX&(Z)P0>bI_+qO}^fc%Hc<aG@6d9JWvT4$5yXnV{vMOQoN{@09#k
zi``0b$IEcMDv8s4Hg}d>tnFsIApXCSOSFjRsXjWNyHtxr!}oF_4%eGn7TP*Ly;RFX
zmrCOI@Lx(U)r#5T{-3luUh87VKz?=gWm^0TqWn_n3b1$eM6H;83;3U_FV`yA4}!<8
zPSEzVbHV4XzCsIok@6RT|GoN3Z8X|y&s9VFqqyF=Wc5{A4901HxpMW@S~{Ape=b>l
zoz{*HNNb_Idsa^#$}gVhoI3kP%T959yBT~K(|0<ahV=hmd=TT-_d{>gVz-I*TGtOZ
zYVl}l&x5OP)Fz`_`FpK5X=%3jG2czvOq;LDze&qNTkqFS)*@b_^+n&8O4j1o^nUGR
zEs0I<*G|@&+4O$xWNkP5EExac{nJ`I+8SSywf#0fm!GV4aeAt6iWasV>*x1<PtmrL
z9aR4mt(i^rPtp3=RR0uhfKByJ(WI9}c~<>XG}-2xav+X>t<H~c75n$iL+*z4k-d7@
zzvKED_PdZiC2QD5<4B(eo;rItPT%_;Hhu4V*b^Xqr|%Z4{!!mtAilRT>_jX-Whj2z
z-+X6`=<nh9L*R?EQ?zhgUfNzBTYa0BK+7*Jg80(aw_D{oY5DFLGPP&ew0w7HlQDm{
zLj7}xmcpjxy+cc5Q~%td%_KXh{dZ{DY-;}<S}~`m{<%XdV^ja!q1CWy{iJCPoS&92
zO>1ORf8D9Iu&F=p(%Ktod(MIW{5A6~UcQ!5;yZ1}e0OX87|)kp#QwWmD|<zxhwCAT
zFJFDP)gPm(G5tM5ejdDf^|0H)RjX%ejhMgHLB3CGXH)tNZ6BM;dr;d?#`izI>wi$|
zXVd$rXK7)t+PB|XnvS-{r&&Yo>4y62R{!08EgjQa<3*;Hfo_#3eWsQ@qWn2p?uhst
zEq_G(VXbgP{9&zRM0~DRfu{PluAZxHqx3RuUyo@`Y}%e4)7sgzy*;KKr2Ntkusnyd
z9@ECWCYC>6`T*7+Jl`?2yvMyFNw2RS_Nn0AtLJMOlpfDdKV1EU){I^vkA?VWtMjzo
z?DN3~!28hM4k|Ce<+qHAgLwDqMOyR@QGct0%FowgUdQzzO@;Ul{}L?$9gt>$e_Fj%
zD`P(fmP(%*Dz6aiEG^Q)c8dG~X+8M#(x8@)rt#^5($!i8x<#V;%d{3Y<uBJ#n<@Wu
zkbh!nrPj=T3p}~BTI*+ji1CeD*&CGpYjmxqze(-~J4@@e0(SVTFkY25Xl3Z2bPo8=
z(r2^=_Lb=8hWcOh#{;F$Yt0y^_RlNbrtL>}V}Iq9Zr8%zqWUr*|BBLAv^4gk=vTD{
z_A+p3>1$d{3#BgwZ!F!Rb)l*Jr%PYg`q5VZG;5=GiS#WJ_0Jnx209?o^6t_STSc7m
zzf`(gOG8`f_Y5sh4b=B$>H9<84o=DXV92|{@0Sj{3;cEI$6CIv{JzppwFWfI-@@{~
z(4@CT{oM{K?@KM5P33*5C9$czPAwk|?<;=|=7*Mkqs8r}{x}tU;+ifkhushR!%1tp
zwXJAczA<aQ)7sHi{oiXHY^wjT*2kv$4{H(cQ2VI<K5aBQAVorb(QA%s1?(7b+?syv
zAe#2?q%{ND09lTQcuLl9n*6RPFJHci4S>IvQ8U3eulY@jz&LFmGuQm76{4yA53h0P
z)#w(9(ue7N=z#P%<j-3p>+yT2KNf?ZT%+g}>_RZyzS9TL)V>{lT~BTk>8<_Wsi(4O
z|99#$*;SB#-5Qsk%@)_^wcvdA7KlFwE<v|CUIM=Y?m-76aewKRHEun6FSTzE#tl7-
z{TbS$Z)5j>o7Z^t?Dr^rKlt4>;ramk5AeP<C+paK(0?a337@K`y)V+|OaBBPTr*m)
zXcrDjQQ%+aoUS*sZv_AO&=`F;n)-K#{|tQ}x<#V$#_EwDi2PRkEIkI@D$(+tttX(Z
z^yBmbbiR}h<$u5CT)l$gjz`hw>GkM<^d$I|HPPJu)=_J~N7kIL4`RIAK_0K?ekkg1
zacqM4Z)+~lqd%hMc@7*_cA@TL?*e<vV)fDcDE=upvMf$-V0VN6TNbY$W{dNItI96d
z4}MJPr5zHy<LOF0^%L?*;Iy)<^*r`i@QkuadgP}Rp8$TKEJ@F0Uk~2myH;;v-wU2w
zcD=qEP491hyzB;jAKLof#Ep9Neo>zFeArETJev9&&d2pcbg48K%3D}=litE!2wql}
ztfzh^@|Q}&C1q3eJoYMZMcK`I?B^7}3$8EbEKAW7*;^p~>zrHl9QJnfZF)Vs89i0s
z&;AfxSC*>he?jHl4&^;xmZrC(gHk8No64r^(H$ZlltjF>>@Gcr{RhN9EKAo5+4Adf
z|1s+xy&6r++fg=CZzRhm#5;ZW>&@tZ90}gxzh7_T_ymk+==(T+6~;64gXmIe3V8cN
z59r}vQhV<M&sp}M?qkmbPg*fc&u2dY9yiygm!Ylx_v_U*e_Q6)x02;$kp73V*?J>c
z3W58;@>f*fPVgW&8*QDBW$D|{RDRN$EWH_Rjb{((F$YBcfF#B%z5Efq7)|MS_;d6M
zw6(uIs<+$XCzt2yJtN{z=t&2uytkn}%U3Vd3)r85$CNL^{crevg!ycGAK}^MONK1o
zNBHmZCx<NFM|frV^1tO@F%%cSFI`_A9J0uNTluOXi~RSNulZa4vZ1)hKf8SGkSTw~
zkVXDS%d7Q9Tpp``Hs~#AtA94?gJ^4itJNbrMSocPTb&+@hUfp`eDavDPLE^L`FNck
z&!+SBdOaC!Z690oR5Tq=7M5?(b1BZ}lMQ-4n~o<9dNHM!|APKsR{o5>mHm&Mu-Aaw
z*%QEJ<<IK-$<pQEDsUhBI`H%5&+B1di{;6e?#1|vy1||YezSbLJ_g<5SP0%z-l(T?
zyafE%oY(XM_6y+8%XjEq><_@-mhaU2IsYN>;qqo(|Ay-O8U2PH&vrG7^N~086!sb5
z!{u-3dFU3$1aynOjpNsWgXO#Qh%PEG8~jswtG@eNask+}_8mREn_LNYt!>l0*sp{C
zvG#raFnd4v%(d<MAp2YJd22t=JHDg*?l;8v@sZxoJ{x@L+I@P)ArTKq{{`Q;_7lB{
zeLeVvd7tXZ--|e{?}g?2^&GPF0K_|epX&|i7RMvtTi1TBPyRuq4@kw}KTA9G9QH==
z18cw3<z5k|@*Y}yK#xFM=c}E10-MfPzt)S<*7<6;F8@#D4@%ELd3Tl`!u<iZ=TUUM
z_Jcke<Fq{<^Y!YHXsYk=wY_>V+Pc0wqKExB+@7b_{-j5ut@zJ+9>t~IP~V!h19~z0
zV{p~lU-jw{>3`EZD9-Z%2K7EPwWoINAh)+=)HjfS+ggVc76$%WMh$>FePKfmdlUY<
zHq1Gu&jE4kdLhi&gl=(&^V4_Np6Jw%h<J<R6i9zyt?o?wNjM-)0ROnwa3=PX#rgJM
zYrW1wo0WCp&aLblA^pkgPIm5RXMj&%cZze&G0HE_kI!Bg;ml!+>yh#6PIc~P=Rx|*
z*Zs>W{Y>er!8fiu!<ol!2B)q&)0zAW#lHaGv+gYCOf;>Z%ym)DY;=o6{S)mB8xZMR
zB<i0FoI0EO=K^O0+B&{m;EYC7dGps@;4CIfe?fhnzW+G)QGVWD|KrT~o!Ud&>jY;B
z+jvWi5C3)UXVdl@=PdX`q=)CxAbw}*CC*|r)mOMK-nkoXZ9fy8k$;NxrP3XczI0uJ
zvk)DW9tPK~OLW$=bHUrzO>#D~#r4aZ>#lQlu$Mvny>*kF5r2vDsJ_qF-RPW5mY;_B
z*Xxp<X=G_Tc!xjP=|i_lbbUU>87&=${Ylr)w>VSSw7;b|x1r&Ea*+S<x>RRByAymA
z9On@Et^M(KXZUgCqY$56KHV9`)>_2z?=EKo`&{(h&H^;G|KT+=oE2#6_<tX7|E*5C
zAMxOj>G(11YoWZd@>y1V)HLuP>xMlWJ$oo#1Xe5N40$WY=MK38o#Py|wGZy6IQ8Sj
z@=<$Ft$5rSh3;0UeYwsUHnlI;8PBHn&37h}9n`-0&H^^IFVES=ruHpz8eyWoZU?n*
zsWXL5?R&~ujSfi1?Go#^$T`UNf>U#rJ5xr{`ZyE(!n_sEEOrdK*ja!MN*9C2%?&!c
z*ooki11p`mCy4w(DFfU;dzG_+Js*5xW{I-}P2<^^iq+hIEu+dHer`pXvk&9e{h)GZ
z#)+c5eCZ{K|EFS|vyc5D_;7ipvp^H^7RMp*WffIJ<^2V|u403;2jkZLr&{M>G_8-@
zD?-jl9rH_6|I^MGw6(oAI2$=m<v;6eXH)slJCmIve?U696@D+Tc*&XTB98}WSG?>T
zWM2n9T>h#v+)eS@(62dj4Dvj1prXl{<sq*FzcBB0X93!3?@nhKx`o^Omb1YYzo4|m
z*}`$!Ki_s9X4C$;+v)RC`E-A)&3TYr2lW+IyzeYCDgGLGYUzj0diFuEv-BgU5l(Ts
zANHv;kxlo*K6Cc4>HbiMv!5;QcU@n8z!`QD<#)X;-02KQm&#Xy*H(Pv9L>H1Tn&yS
zOWEL1MVE6jyY(TsUr_O_vltze#CX?O(e2#F7Vi&gsrb$rf3m1ADCI-`JrzC9v{Qsj
zr801LMXxi@=ASD5=d3})^9B$fH}^;9Ap0Y9pEE3i@{9WasyO0|v-yO|BhGa6DoMnR
z%AcIo=pfuYh4-OU_B%VsJb&VtvmZ_C_l(M8PW@C-zBT^;;*3ID=Oe#5<83~#@>gdn
zdWoz+`Twr`&6&;~4L%PHg^BV;T>y@&{C&vRpa+MXg8swl!~C@W#Z~_4%wo@g_~n&<
zIdj;Lvh%1uJYTsQ;s+@%QGE_qADiks&Sm_AmXGQ?-Zcho9e=}I@#s=~Kk<!~VXicr
zQz}Qfve@E#=;P*&a^<0^|E5)*;M!($My2X%MqAe_PFK=Dss3*h#Pa}7mp)pU@-HlR
zxnjuD5?H?MO2gHFhVL1_AxTeEdR>X9iS%^7x~%dfSKAojfJDdp2$yk&a8OzW`R^?K
zhbsb2>u+P_XjcJxiTonOJAMChZDot^WN)tgm#YySkUs`L2X5i`_u%c7r@7kLzk{2=
z``Dg$U_J}DgFPDj4!DafMT3Lor@6|;iuScS62P6l(_LX_3NMka15e93-4)9g=X>v0
zj&bF%AB6ZZ-x;n3_9F0Sm1ns2u~&e<t&DUXwE2IPXS?)BDqqA0D$j8xve$vbs-j)F
zHk(y3u0oqnulkRx!sfHfC%9VJ^^iZRD$do%ei`eJcMaM+P&v_MoJIA&1M!Qhu5iV(
z4}dQNPqsO+>PlCx&DU35<*H^MgY?PZF1EOz^!2(#S3leJE*w9r5?zsJQ+=m^@2a}m
zmBc<5d~ek?u5C8^t0uYRag_cFh|jG`a)qPwrQ5;ttFCpGpj#aGf{*#GbA_EF(w9p4
z;Kfzfxf0o%!NpbAyYg*bTQ%9Wo81EOnyMRI;pbBRL*QqtZgj=4#rV`%mF&u5AHPSE
z-l&@5YGy}(_f*~NlFp<2{{`=>N^!-bt?}trS0bABr!T5*b*0(-L)A1_md$@w-RTO8
z#^uNHV`Jq^mqC{4{O4X*1iHm>1=QzVf3K?vP4guq*Wd5zW8Vw$OV;~cgJ^0`T&3R?
zbv~9aKML`Q>u0-S(2Mx}8?#+;6qm&HSR%xe*y4KahV_}QboNrnf7|*jR{^^Oe9Sk;
zRf1lG=f`!c=eXj=4=>N1>mPO{k)>)(Ki5@g^Zo1Rx@v5mz5WqblP!N-WsYmN&BuI?
zx?ttQU#nAmkN45_!xr<IJBQ<=wqt!m@loRZUF2`a@)l!%KLPoB(Dc5cC)Ypjio8Iy
zzg5`-`AgQ%ccr42$X|fhg45C63e`W~mBFU^=ex4e0r@DThxysA3UsT3+B4tP#isVm
zcSXbu_t!DseAgJ8tD(Mpv{hfgRluhD0<L08FKKOXeOVrGwXpw*&UXz^dai$|%eYX~
zN7uv0d`q!EhwtB6ru%o#tbdZ@^gWU7>z^93xPSKM`XW~`mRBl`hx*#qFL%}3+_^sJ
zYGz*r@t@b1xKjTu>MxaU1D{Y`>Z)P;!4cJEF5^EU4(BW2an<FnF|p*Q!539my3*L9
zzH6&DxMC(yyajw`b&aclt@vR6S9P6hH=6dxW4@599c?`?6>@d`SL9!U?+4GU4!NX@
zgiGa4C~sbMy-Q|`=b`3<4YYN<u6ISDt@7$!@p1O@>RqX5tGvywbhapOQT1k52HGlb
zvn!AC^Zk#_t^zb|uTMhyGBj<k#noF}TWwxf{fw*4=BKM)a3x+$?Gf`E8mqUvCZlQl
z-U-g(I2}*7yYkpaVEK1JyZ~)&f7@NfY})>|yQ<OF_P*V<oAOI^eA({W&pv*ym=E%@
zOTI+3$J!qnU8!u^9~xbG=z!#b^n0osT@jax^Z{usc!&QLR}?!2{9*O0t_E~ax(s}<
z`gPYfb~1XWs|jtb|7KT<%{|r4t`3`zRkyhMZ63AZ9hV+2>ZkG6y<v}Q47yaB0p*{u
zq1~llCgP=10DSI-4_zhfYK-r5#ZRPo3;GjR%;i+xH(>qY{jP)T-@!2d+odOnxOF`F
z+!c<t+W)z0w9WtC@VToVZLOaJt_C)(p98KYN-u@K2lv}I9B}p7e0KRaF6jzU-x4Vj
z<K3=Uo6j!)-j&Lx_1WvnK*R6NIKKYRRmP_E_di$Il~^8bzvor{&lQfg&gXx0#iD8X
zcKDCD5^TP@@~A7B^7H)Zepf0P%iH1acV*Z-Wy3L74tkLs3+?ar{o=}FUm=z!>larc
zx|Pqz2V5m=Iv@YlHRdYO-d2gu$A5E8MpJ*MZus5h<2c<P{nJ%ri_h2~xtm7Bk8}6f
z;{FX`ZYhz<r|W@HZi7wrpWq(Drut8GN1>_yLs_yro8zK?<0=(*4x7qT-Fa*(PjeTu
zsXX0Xfu{1ZH#prL9H-@RyJN2&USCga@VJv~F4$nYGtk!hJK0@xjYuDqZiN0_wIRYC
zIcYfm4*x&hv1lv(Xm<}fAl(J&<0?;crzDB=0qFto3-eBQZ$nf2s@9Hix1g>3XSny-
z;~UO&OV<w9SGyt79ZQyTp}d9-XSw6qMWTFgBHCL2XSuW4)L&=2YuMCZ<J|iwKW=Z0
z8=~A1*NOV9{O7nwvnl_%?r1jUKhGVHE|u0n{W~{AyHjo6z2SU!8Jd>&%B=D3dd^Sl
z;{tcy^~1~e(S{4%Wj24gA=cf9w)*EHcb6@GXv4+s0h^C(xYTV-ruI|$m$~E6RR0eD
z<?cj|)Ap6%PG!^fb%oo<rsciToyVr-y~<sJrt*H@km#<ldDO;h+>JIH8<X6-Z9Z+|
z_3j?B9D@FW@1wf=*e`>pg9p*p^4{dmx?#9~re#fW7ox5B&2IU|;rMwQQ`}?FR{S=1
zqAi}iA=RB`^S?LV?#>;Ne!5$~$=-i=xksaEd0~E^I}&Y;*LS<4N2I^o9gnt-?=##<
zw*2Q+&TyxWNI%n^VT)hB@jiFXi1_{P!sOxQgZJ0COKd)`@&R{^%~fk3bZ<jj%RkE<
zGezXL+Us}6qpj`R?@naX`kw7hVbl7~bk9Uv%ai5KLQ{V{HYdwn!0Bmwd&oU#i|_Df
zyY-vx{W;eigSO6}=D8DZ!R6!gv3c%vv~~WJ<IZ4<^QTE0bKF^It35gHg1@<g(o1i{
z_S8Q+$2~bklpmD#qaSr=p-ZLj!8dGt%w1;l)Qyk3o5`~LzPP@c@7~QG3!brYzPlYA
zl;XkT<}Pp_MAP}%iqa?C{pePSj+c4vh+BvIe}_NM9fe*br$hc}{(u`A2Y+v!_yqWv
zFW^qXIQ4JF#(=wlELTDNv5iaJ+t~HsJa7{_AioS=0^ZH>R&deA0(TGlL(E^`?juWI
zfe)7#xFc_)^+WfEo^<E3X};)FZhfkVcjNnqS8aUCorQkuIBM@QcLSQ*+nc$}-DvaC
z%tCjI&A(<YcekUh`?<yLE?a!<#-O{8<8;5d#NC)G>ZkH+HkP^D(bn&u>)ZomM;|QD
zvl}bi#x#-MnvYlME<szrzie=4-7exmN&Nn@ePfL~kFB(e`&V^t2*Mxyo&tVjW4+~3
z{|0w29CiZ6H@izPKeexR?Phlk+WI~2S$Fgu)SdyjzV7rr?~Y}My$P*c`@B1WeG2#h
zI3I0o-!Hk#&{Y1y@|WCODZO$7)IZJtvU?kQ26z^@iPGc!yg$~x>`qU^`W<s2{`SUK
z-SN|@J@otfPWNOo-tX(#*z9h;lhPMK`kyzpxaGUZ;`i#mHturwr;}fVc*Lf6+zEFJ
z2PE-(|M*Ssxii>}5Z~c%clWc~z!z=$z%AWF=?{V*oAZ%75*?I|f$uE+*d2|wmiJS4
z9J)oO<@?N?K$d8EK65v-H$wY*Hh$$!nkmW;N@si^%KO@#jJC?_a;KqNWa__ecRHKO
z?{;U9x%_T-JDd9B2e)xAwf}M`e|Gs{cNF_t@b%^YbH|~nzM74F?nHEpMBC?2?#UFF
zrbGIxHubyv+1coy-KqD9@|Q^YqP$H5?gljNe^+h#%^iKei1YimHx0TI(eOTa%>Rcw
z6;1UY^Zn&cM_b#|Uv3||RN4gTr)~PnEoV@Fy#k)O$zfEp-vwuFI^K{U!1nO<X_#T4
zt@6T*C|i8qrZ6L)EQ|4J;U>i>MAP_G050SB7ovW@YE*Ol5O_Mcf#WpaUo*CGeEuDf
zK1(y2IZpFKbz?Wje-Y(n>Bc^ei}zX0@;i+Vw)&x{&uMgV`UvoJa39Cd#<<HE;P?cL
zyNs|0slUbeIJMMmG@z~V&oGQxA|8+uA^pNlhS7zl{$Bw$d?KDN-3sxVO(z>EXzTae
zQ;n^&DgQ$de__+VjKWNE0k~z;8Af^*xenaEDbi?XzYOl$6lEM{zYRXR>0Bdfjz}Mr
zJ_C=Nd!7-4wzh|8BN0u<-w#(u8|i5HeHQk=H#VMcWRM*+-konWvuV5=Z|p`>dB1HM
zZ$v&M>RTd<`wiKvCm7M}KcN0;{s~4rTlt7QnJtb_X3Ye{$37Y2DOnSYLUtthv5gaq
z67~fg-^RX-<4t5K34FMGf|2sDXpc32>%T?=n~rA}8FIFW)Bbd7%|%8N+FGA+#^|{i
z=l2oC8PVuYWjd5U%^zpPP~0Kj_w(%RIHR5|exKPMxY!7PgvuB156aEI#E3+9Iw~Rm
zG2bOdG<zR78{)BSeV@o5Z^X0deM6TSiD+y6U1p?`Wtu;HnUT(>`No$S8El$we3_9&
zmc)GEF*TPNd2BHscwEgyqnIt`509_8+^8n={+?j8q3Qf_LQR6vg>L2NFRnHYv+4PZ
zs|{%$_P<QeUx4wiC5)brx!RC1UW&h`C)QkT#IO@#`TJ*IV|1W{(sb~3HIs}!j*H*t
z6Kj%;lpImMHU3;{_|Vipy_we<IW`~7yw1o+Q~Q6-oNN@MOQnaQ{3$gz8ujeO;Lf?p
z#^gt_d`Zj?n^tqPk;7gM@o6<FM*3qE-w3{^<~E~%%)f6=Gpf<lo||%}84<Z6{Sx^Z
zNdNWh+l?sp8{kPfw;M5JsSW(XyxWZgw6*=-VRW!*`%N<v=VN)&=a9bRku)Qn{R7xn
zGu_BS2c_OC#eCU2jeLsp`b;;9ZHDgw85K4^RCBk{WOGi<45Q2Dg*6WtDGO+M2BE$;
zHf9-VZ2e<+9-}79m`TR|J9BN8QNTV4;%}DEG0M=T(pliuH4htMPf&R=;I&|#eGPb)
z|6yY^JDr`xeuC2{vsZCEo&7Ysm@MrES3~*r><-MIZA9i#fBwlXL<gkPJ`w4&jr4$s
z!}IFkP|aMU5xqpZ6g<oSh!MAt@(Vvx^N10)h|(v4U#OX9G^3YD)4;FP<QQf7ls*%@
zv*uBw4Q*}DxkeYod41&?{hXfa%QeClV}6Xo_h$^l=A)VOjnOv0vgQdR#pYwaJYy!B
z#{XY4^9*?jwMRUUdd#=bNJqo_&@K?qw=Fc9C@wz+?R~c<-)Lbk63eqD-)LtSg4=5r
z8~fSi;7`C^>^g9#Z;5f3-2#T^os0qY*WfQ}mKxGhY>zx6U6Q^7%j^?Ah57#AD6$j|
zK9sf8n8`j1eBXisBcId%2RzMRVAP<k{i(o6EfD2fzmGp@bfK;Of70kf)BgKQ&67sd
zlOlaUx&q64%7{Z-<MC5QlFifoPZ?=sp3l3?n8~L3PRop3_EaeE&zeFbpDbm7!)gnS
zdYg^f<;HHCPp=Ic`)xkAw#4YMIj*+M7(}-^M0wZLRv2whiT3A9OTklXHy9Diuz#iX
z;L~esj3}GKYD30kn~mDdhR^1>+6E)f=5uSe8pY^VhbZrw+HHnjMCHE?zQ6VrBhu!q
z+E<Nun;)xv%}BF(Y3&Z9*yiHeokoq#Yir*yw%Hu2Z82KVtqxJ&w%WIil;u?aA#hmj
z9wXmoqjs;c)#kX`c4N2AEw%fM4x9JYerELBe0uGdhOuI}{Bvs$8c{Z1Q`==Epj#cH
z{?6J%Mi0ls_QUyf?T?0BO!<W$tL-x)ZC+b@)QGjYzxJ4sX!G%PzZ$7F7uOCNKAS_e
ze;PS9Z>x293efQWbg0i=H_8(o6!qszCxOqXQ#}K0n&0j6j9E!>n%`}Ba@pe{eN3I#
z)5e|(PN+M{W2~a|G+*x&&lon%&-;fbmQC~XPV*$PX@1@ro)k9C?~C-zMAQED-Xr5Y
z*%Zg|?$^vHPX)T$LC@=+>uF%q^SaTVCNe)ye7>iR<MjOQ`JN7r)APmWdk(YddD8Pe
zgKRo~Ip3p~h~?{6=y~DuJ)_xleR94hn#|85pYMt1IGqoj@0rYTdOrDlPa4PR`Q-CG
zKDL}C#<TN1xtyNH-|?Pmv^74(c=n-7rAMIuotZJ7gX{qKrn(r<AQ|Tq+*Ws?Cu}vY
zAMU>kJ<Vu%A1$Q6tLi_V{pc1)4S4G8SWiN!NFR`1VCSNjNbiG>ER6NUt`YGiQa8pY
zc(Tv|=~r;aBNIGr=zPijnOL6xdV0{^j?=(tbr*U1*tC3co_=;TroY4!Q%3bq1jG9r
zJRR)Y*ooy7_hI@=J;m%tz%%ONJss?STnNjz;4;r3+UmcF9(k?EKkTf(dEjr3ST{0#
zPvuDGRE_l3^&_2IJ<?D){I!m%gyZY1x{02_5%DWL9Ct2(<(cLm@~Ac7$LdBp4;;He
zlu!H1(z+`>Gtu1+dOuB~C!efPd5NCF5$O{>O(W7@<LO{ieb;!pY|g8@#&ej=<xTSR
zkH|mCGw`?gAlf=!PV$6pwD-p(kAb$@JINDH9x6YA<J6u>o-sD()lKq5p{??hJTYi%
z{U%xcIch!hUs2t#U&8(zcJtpX(y#hk`n<YphsqP_^Xjhi#AAJ>l6c?z+PdpKiD>J7
z`}Lm5=vIm9zuuF|ruwh<%w$vj*L$*T=~qE{TW#s{>Lz=_Hi`agm8kw3JW=Q+@*Zdp
z{GQ^8V}Hd?Vh^%Y$$Wl!qsM1+b={4g3beI8l08jiULVPx7F+uIx@1p8jcAXR{uWOj
zo7UGYo<f`R>TdBgk-5ASPYasXUv*uIr=Qc)_IsNrycWyn^tW04?=(J#=b7q;JSq}=
zC~Mf4qNiHvM=iY-o(Fg&b;vhBeCq6JL%s|Aa@{n~XsXXa>8E*O(JhWlh`;y9?Vfn{
z0`wi81oo5YG*2Sh+8(D5mA@L|uh$K`5<Gg|okMZ4{p_k6>AiJ#jfn57OCR9_b@z<$
zp}LtPe5CH)5gw?!Z-kEzWq2lIds`i%{zG*Sj))(ro8`&2#RuwqBjU%0W_v0y-sz}^
z<=Iu2<*B!MZ`~ZvHk<d=J>+S&`9NK^rwv^qeF*uTp+`J=omk)2{xi=Lj;8kQs+;GD
zw|QS(&WQHxt$S>Q57a&GnThGG^5=VMMwGw6(?I3n{=2tsfu|7--v@>E?5%sk(`<_$
zsLS)T+2RN47JBxht@WL6)$cqwOB^qUE#8+E9$M@<I3oR0Pmj(22rcytqT&87ZVv?>
zJw*GL@ZP#7J#jYgt9#0mWb=W#LQe`Bu5U2?a?ebg57e#j6r!#620bOV_};ppr^4m~
zbt^qJBhr_68f@{sbtRrQn-A2j_Jq}o_FCny8S0M~=#OsSkVnz`u7~|2^!F_Puzv!d
z5gIb~=eSVWP<aCopXM(gvi8MDpY}Ij_%~lQ(xYw#@2wjuZ<KPjc)#mft9<nM(7F*m
znprXA`yu~Dp{fy{7^)uONuf<6JS9{&<X_Jc^=%p9@u8<j_-JOskRQhSo*m(dp{*l4
zDfHq9PYG=w@=sXbt0O!<^x6m?&1@R-6IkEtBRnzGJi?PgZ;kMjQ0tJxus`1&;qjq8
zBYZToZOF^8zV}9WVyJzDCxt#5;VGd{hWr;U-{&JdKJ>*1AI<C-aw*pL)d)`v9US3F
zp>IZbN~qhia|7g`9{PUB+yCZ0;299tN9-Tpd%|t*&HUao#^$4$KX{_i*8R&~Pn^xi
zd_Q_7+uWP^qbI}We}wux`8GcgI^roow@Mw*o~g5cvf9hr|4*JWj4zRYhWMONzo(il
zb-?qp;08ARzH-d74c+aa{pFaa&F1l;pFKS`AI<#5BW<SfjP{pbJ&`s~4E^p&vUyVI
zPfv!;Q$h}J0h_j`QQm5s$A?bvHraeM^F;4HHf>LecfjU}A<a8_3$;hYCxu+zc$=q$
zJl-@mZBHk8vuz$9I@w!n^U=&xy!C9_o=)|)**r1yPj8>ilR~F?ji;%8k$y_(3~vmZ
z#)GrGNj8rUo$Z}z^U=(4-dr|~2j_UJZJro9&)Z`2q|kV8m(5c`7ka}QsD2s`CU{5N
zJU;YaZ=B6XGcWQcvuQlI*qd$h#L%VQGMgubCVCrfo)WskyPvGk_<gmvhfU-2)!qR%
zjn7wm<!7*ciU$2N&40Bwf=%Q5)m}K*z+cNK6}HcLp{u=77|)knVE8@2n}`lbBEB$m
zoi`P29iMLSX4w3X&<)-kn|m{F^yb_AK<FlKF}elIn-`kmm7f*uYnABuajQ2SP38Ay
z-sa7+xnSv3Z;j3C3#WMxkI0|qjeL&Q2c7>;_r{`I@Oo~#f4Vn~%=O>t)whcDEz+s5
ze8+tEc;nGQX)L%fbdNU+-L260G{c+2rtxWpH;+x@(+qC`o7T?^Zy}rde}=c1P5nQ^
zTf(OGH^W=Tru8?&TS0bE|IF}KvuV7T>8-JOeCS?pz0F56@AEdWX}rkrZnb%0=t1u`
zn<s_*-bS0JgtEL%Y}%i)z0Ed{56$(q*nBke5$|p`?N2%0Hk&7g9`m-_JSjBayU*q+
zp*-(?HtkRO-VU3`hZcJe+I%!~iMNYQ`%{6p$L5Klr@V)4o)jwb_SrloRP60%(|B0o
z9k6+PXtj6H=A)UVUg>$-zQlNUQK-xtX7j|*TCZ&Lq)??-w|Ppa+H0_BJgo7C+dMv0
z>y5DaXl9*vG@Hi5dhZyUCx*6oBW<1(dd3@N^OVq5Z#3H4U$=Q<(bo0-HgAG0zB;tc
zn{0DsXuCJv=K9bp-fXnBzwGeVpsnlI9o}se=lyMmw*yVb-)*7Sz5Se@#+znu&I|Va
zzr~x6w)X#B-e#L02(@|#N2K5Fm0uM31JZ@CzwWJj#~X#V#+P@!IUJ|oXWsKhz9iBI
zrRyQRZ`pg^WcE~WQ|Ntf1N%YnTcLKZv7ORC3T_L1;7wsa3H~_rp|_08zh8dD<7q2?
zKVX)B*!2C$VXuSyUxkJ(=6iGvdz85U_C2@;%WqXE{;{`#P5D3eZbNtD_fu#2KlV1E
z^W}Odzc=$^?{1D${hxT-IZofd{KVUVZgo(7pL*k77Rzg0KYr#-MO)j?XWn#M{MXFS
zyuK0fFTB|{9|?Wo%_HOd#KBO9x5pOm&HU2aZ*#%Yue^GrsDBB*FLjpxpf{XN?LFun
zgQojM$JcjyqbM#tcL_XiU;ni?j{Q6=zqh{2n{KmO|E;%xy#wN>)_><MMwd$OfPKq)
zy!Gt;;IZ|Gygjdo_LNG8!ROU~?+tqu+sF5Re(>rx`vO0BBgyhFkbd**UT-wp@g>Yx
z2=sbm(boH8d%dY>nosfX`d;r=j?;X?|9RWk^!xRXUi~#{j}GO*^Tys}G_9XQS$*CD
zwDmoxBi=Ih6}jU0f5cnCP61DyeZ*VCK8@q`Y;pbl)uJQbb~e4Q`lxq5TYOJy|Dt|x
z4_kasN_YU>sr(b#H_hMgm6}9*yK%lp8^mQcUBCY9HP~YQ$GiTYy^(D3{mMgGzj&kA
zVm`>6>;Z2Ay3^6Q5Z;HrXuzAqz7Fd9aM5qxbabiI2+wn0UjLi74IPxk_h}~84|)gL
z^C10A^?!OJc8K-`r6TYh^?wcRzh&TAe#wL&{I!nS48Es+q%&-O1>$q+9cC<+*Q!wd
z<NlU^q~Tg)C{Fp0H{&tCHJ*l<lhM}sOPHCAw)W3aW-8hm&qrZ-!_TK#rsvag>QCf2
zJ)gF~X7PMlLA_%7s6IX)Qq2nV5_vZ)AAIh@tYLo!UIX5WZk4EiG_%F#jC#%7kG9&Y
zn+GXB?mt!ax*7Gl=zrRNYwMk6j?KN9ZnGKPDpCI!=5F@GSBdrGF~fF>`~m5EXwNhC
z9y5XM_zJ!kSZ|u)%@jWcytDo!GmRYyUQ~FpS<Su#+`TZuY-1;(Pc_5epzY%}@UHrQ
z46Uzw!F%feIb?Ca=)?NaBm71Ezs#AKzuQ6SPd9VelzxnvZ}S)RXP6aeYrH+vtg*SO
z{!DWl+UoB}GyYA{K5|BVq?yR3{yNK?j1EfF{<F;rv{n8%v%%)7`f+BH&ApjXX2e^=
z<=<0(ju~xp1~`sQ^_^=buxb6AXJ(_V`pz?R(N=$)XBM-mKcdYto4=?(->k9ahwpEh
zU1Zq@{XfkgV;*Kd!tQ4W*n{k1@GM9l)*_Z?iM)=jv&Hu`MLZl0-&=urZ)S|yvJ2Ng
zAKx!DyU?^eRrME|(XCh>ZqK##|2A`N?#+xfTWl^^I>8KooBEUb=OQziEYo;#k(tVI
z>d%YJ40J%+2JLyNKF(}m?*>0pe~B5t8`~#+3I4V|-Yh^{{e78PjJEpwGP8zF{XNm#
zYV#NMmz%ps<iEmfx4Ad-3bVuJqnTHlJ!sm$f6YuZ`)%>w%xlcBcW8NOe3)d0+niB9
z$sEn5<xMgp(N_OnYx-=it-sD}vbi^Nve{;H!O|Pd4s<K`=S^l8na7Wt%mFs_f3g|-
zu4tdtzsY7hI>`NbvuW%RajQRXF(c4cf8Jt_VN-vmm{B%=QGe^uc+d;$XHDVM5&pjZ
zjuAdmpJv96sBgNNY;$ksbTgYQABFO|eRrC<?BBsxX5DEPu)_|B?fEXVnC$^i1DCN+
z2Tupru+Il~`_j!8_Ql{Uv(n9d?5i>V-DU?n8S~$5_Mp2Rw0!rN$!(&)$lurBXQrV8
z(jAcg`}+IMguTP@BlQ_(33`c~0r6S>2h1Aw!{FY`2h45k1sH$OY+*0M_=Dy?b{WQJ
znO*E!jL$Or(JhX*?}hh6*89wi_i%m7FF<^n-*4uTrCs3TH~Y;NbWr*P4DSap_n~S1
zf4b6dcA+~RKS2Da$7h@U>`M=d-zPH7LG~i>Pmj+r!`>J5!S|%WKQDa9j3z6mb&B6N
zvdwt*EO2;eu9?Vg1S^~8nc3`7UrSPwf1X)GcBFtk5N}}b0*~IDV{T(#`VE{PZhq8k
zVm}8Sz4>vog?(n1B*kvdHQUfj_<JR}W(Ql$&uv>Y-#m=&cF_6S6Xqbt>HO>oQ*Rf`
zN6&+QwJ6UV&8G9kfEmrE^TkDGJe$rJ7nzgM-3pz5E;7?N?!xoYMW&A|z4NFz-&<tn
za(enbWU*Pu>FIoSv01^U^WDW}1EqJ+`Qu`<iQ+h3`vQy2eVo1u`eXC#rDg{^1kMgD
zHM`K(`TA0G@&{sht@&_E&1yECpBI>i(X_qz0tIH+htxkN^ylW;PnkOVc`W}aGaPM|
z|CE`_rt|-&%yu@Fzswx{5thf-AIr>0va}P*yK?g~Gj2q@&`jX?K8Vlq7n)h<p!75N
zmf3}74#nk&Z()DfTxjO8&j#O}S!fob19B|*uFXYe1-jdD1Dx+vWfqwYHrHpaFgw_H
zL;U5;pxKAE#?Mve0GaDsWlH;~f2h7yrjDlH@7~BPG2<!D%UfzDa(ZfSsX2K>{!%lQ
z^NaR<n7PKR7?HostofT8$kHNs|G~YR%gpA##dmYO3gWXM4l7?8KEGbert|B2H&+Z<
zygzk8{jkOP^&^|B%#IP|uQ$86{7KNik3YKpZ{=4Hl_%cM`o!jqLl)&P+gvkbQU1Ek
z^?%F1c_=RO&)WR-kVXEQ&Cd*3<bQGV^Jdt`v_2k&_B3sN!PMEyz;A*h(A~-hlVSa5
zy=X?UzXWfa{h}F1b`-<;`TPDC%_Md+_!s{+vy8n4{Lbc=%r^E`@DcxZvxEH}__NL1
z%|Z5h@b~_gP5l$mzHUdS@a9G{5^Zf?ubR>5PRH%niutmynz6R{o10%X6FL8c8{mDX
z{@2V@w6*^=nLb<kW4<Ocn=EaD<(K_UX1*<c+?E|?1zFw-ab?R+vjz>{mj%1PThZN)
zHgNcsX4Cjow7*44xB}Ymd&7)GTkU_-jJCzQ7rtqxjflTx&itEwWa$$q|DRjlGV|C+
zz-Me}F)K!--(@zC<uh-D@3C&#Wo~0fgCEP<Wj3?*ZgD=)YVKzL6MSV>tGSPTF2>(B
zJJ=I2{<hh}P5{sH?>76`)4;u%yUjte^bqEM$JF=Z_J;fS1zX-RN29xym!Lg2&w1C3
zBs;|VN(1|B=`Y#RX6B<i9Ys){+y9=~z<v|_uK#_r*_QrLR=e4b?pA7&#r=;D%mH=-
z_)yjdrv8~|k99r$p&5Z*B5!$Er2o(y!~P$Xe<<riGny@ZCzkgkGnVZE_hx=%Ca}kX
zJAM1iB=&{i9sYf03j4B;;Cm5UJ~q?X2@p>KXOMaP`^3!pn{&w0^^ku0mQTzAb|!e{
zmQT&H5$X4v)f`_1@k3er&Hd~K^k?Sb5$QiS`#HV~;vJ8CZian6yuOb4zA$yN^fAW2
zFvpCDcbHKeKMe7yvpaaaq3!+ICoR+X8U4stL*tPcpZr@63|Wj%3$}c1##4FnH#fuk
zQMP<zCbEBr@{7R9=x*g!*uQ@Db(ubNP}X`R>9vQt%p8h4{1A8eyUcoaE?D+|YmWH>
z*S~ZVj30kJ-fhOR&xHKr=6+|Up{@P3=WoknnU-himhXq!Psf8{i{&ZVa@d?{EAPZP
zy=FF9z7Xo0=Kr6Wiw?-wgQtTF(A^5npZ(D+V~hE<|H=N*tY@D9?T7E(n~h{gWsF$g
zKbpJQ-$43fzCLq5o8|-enLX^I5WhV8s5!v?1JfTh!#Z&NbN?STbvE_?Q8NN<_5V+1
zEIJ_H3+=Dm@{^fDaqj=0%xpIGf4^Bm>7@Xq-@N6R*}@K@e>V5CYtg@$huPb~Tel3D
zF<*-I1*A97znOXL_c8sT*^jo?-yh~6nV07eGwdr`K3bkXOapB#&!1*AncM%T8Ox^j
z|7E74;d`Y}U*i@jJPRF=dcZrkIKrFRf1r;Gk32x_bsrM(<HM`bR{O%j>(SPD6c(Oz
z5Zj02LF<;V@B%X4FP}R5gz#cEeV_Y;@Cvlm{u9F+(WO%S6!ATR6T|njZ$Qi81C*YZ
zPYE|VMSXBShWm#ao`DWZ_rUr1`&+c|F<(>rMR^Xt9-ht?<vIM$@M?5WIvtkp(=D#>
zt?Yk;zuV#tZ(&~z9`*G9vG*?ERaHmd`0Tw;-~<98VQ&OIV$`Uh@gCIJsAxe@V--ym
z1T83DkdqKDDoAPx1_g|kXjHIxj|!5I01>gG1skbY+G53uHC|{V6@`ilE!tH7v)9b;
z?3@k9VEca0_dU=5g=asL-<nyoX3bh_)@5H#4|kKncW8TLxh;yNJ+j=74Mu&k-N;|X
zJ{iy1ZcMS*+taNy82)tKst~RbOvAbS*b>)Wl*ISkM&*w)e9zsO#P8*9R{pJq-^<<J
zj(_-)1KiwJ-@adWIfBoxFPYNE%`<o%`TLRU84nb`eIMhwjN=A3(=x_0rX1+jDSn3W
z?s&{yqxeO}H&2PVy+0EFS9AHh<9*#V2BW@x-8}}Q{Jt)2_2p51UpH#-ueJQXZV!V|
z{vocbSjs=t?X6hKKh%vGyfwY*a=zbk)8X!L#ZMZX>(&^2M^xg~5$;08@;>qr?jpth
z_bHBDa-`d+cq!NCWX7un(~FExUviYY(_kLoj0Z01=jQy)uMg_m-|c5G#!G*9P&@vR
zCH>tS4Bnb9?+@g;Wd>J7<^6#?w_N%9eu7)6e6jafcb@Vk-X7=9SN`mgd_VB!<J?;1
zOZ+|FtrM*A_jq@eVu`;exXp?s{+{4&QY`WJBzLpHQol=<oaF9QzC7QM??yfj>VL(O
ze3zZU|JJ2_&i;R;YJlq|@lSDc3|>dVKh>R`#6QigN#Yl{yA;d*^K`ezHt9bf4fNMn
zr@O@l!~Z{UM+v5PxP5XK{J@PX?)HiQdl-dod6N7YZl&_iX8!V9&T!`|p3Hd6k~7^^
zil1U!vg9mxLsI^M?k45GZR7{KyA*f%)R#ZojeZjNXLtM@w})UlgZayEImgWr9392@
z)+Il5`zapBcn0Hq#Wyp)bIBmLQ1M*GcQYPp@K)=TVt#&R@?f`I__|&@&#hFx{NBZR
z?rg>Kdl%=qRf^^JE-rBA8I1SqE_CNB7Jpypt}+<@{*k-JVD$GNxtk5fc>Iy;e(KkM
zYr2fbi`<I^>+{(cyQ>YB@$~zfhq*fqhW<<3JqAPnCGODe?frR)J6mw{5%x#Tl1toq
z23JI%W&9B1g$8f6{yd7;6SrLI*0sYwx~14%qxf6qm)`PYccbEeFuwYh%iLDQy|3i`
z?=6?RyA+?u_!qYfcOyGY{j9?o-*w9fcc8)5w35qze90B=JjE@HS1cLnHX4lm;V5^N
z^3%8T^BmJgCC1MH#s^Nm(p_WtxPSE%_ceppk??=w?lBnt8spO6jenvq@c3A}WQ-eC
zd>-rj4P#gF2*$r(a<v;%d@bWmjQbf3{nxlf!q@(Ety`Rw|5|rcQvPe*8<O&0=l1^0
zx2KvWvi^6M+~8IzUcmT6#*GHU{&DUq;p_d5ac;BlqhjwkcY|WFcbvP~VAy-3yJ)AB
zSIhdh+!A+N46dLT8Shw9;ue2y{G;_Lbw?RoO}}OSH<L=;v5G%poHluaTPE`6yy%iC
zW$skP{&~^AmXx`b2BZ9mZjJC&|73Sz5`VH=o5a7#tqb8M!DR0svg>YgUrXZO>~2(k
zjQP9cH@mHZqt4a-{_kdYyTMy6|M#U|XS~y3oG;ws?os|r%+D;j#f^T^-XBxl9wFRY
zFrCZg^_(`<^v~e@X_{i$Z}hC2p1}ToBUV?Q!2W)tf8EdAe(m(1R5!yNsQRC|j>l(R
zg?n*3KEKcG4p+Xve;ZOa(~S#`Uc>hMsP1-misA{3iy6-_827I$-5TL*dsMm$L%3Ej
zP3QbyPOo&E6whUxSu)Grm?VFPyIJ`Qn7^{(4tJ;GMMnNkH{;9p{+#W)g6Vmqf3};e
z_%$Ox#~qj?Ki3_q{CAA}Tz9zQkB$6Y?vy0?Dz{wu|78BkiYj-Z;*7uh_TTNUPLjXJ
zZC3uF%wJh?kK3BW|GB$e`2~jmb2qZf)Q8SD`sTU0g4LhZZl3Z-8u@B>kmB)1{$6)%
zlKg#cT=~<D{C)0h#XmRlHSVG$`TN~Q<v(fo_q%J7_z$?RDSx@)Kj40x#DCD;sr<F3
zJpMtw-9h_|tefw~4956a;9hL-uWkRlr=o0uJGPztxVneja)Y;~ujT&wqq2qWV~Sr_
z+$`AI#CZ0t3*Fp*_~lj5yIg)n*~4zW;!g~I#2sWX%74@?G8pAQ>J}S}`1qJRDul-h
zrmtDw#Jb1aDM|dt-E!rpe?~O5?s2y&iT{LKqx_=`{|R?t68}lJR`~-A|4FwgiC^ok
zR{nX0U+Zp9;y>l?QvQ{O|CC$!&%pou`&;fH!8FP6pLXXZ@t<+$EB{Wzf5zRO#9!p@
zQvO2bFD+f<_Sn;2|6;edV0xDMnI((eyd?g!ZocxLXa22a&$@$>_)FX(<*zgRC2n~V
zzs{{x{#%A$=Wa;i*SnjP-)i{vZq8Tj?OW>h6HH$k{!+I*iQnK>D&OA8>%qDPw<?L>
z=+-E|hv7H6wMqPCZk_V`8vZi3C5gY>ZB>4r;V*adzHV>d3O8Rcoo@Im+!;yyCU>^-
zhZ=s9+mgh8&TSQ}_gkKGw=0(WEzh}o4CecL*YbJ)w3Y4&|7u_U^X_Q|Z?$e4$LB}W
zpLYi-zMb)x(_e6l6#MtTcTD)DJ1Qyvi|$y#(aYGr*>x|vam80NzK8Kt&42%B{vQ3*
z)$XFC{J(M=mGA4Xz3EqObBMnogf|JMw)1(utoxPgwzaR%8aF1GO1b>|>(;m@B=Og}
zrzw9f^MAH@ZD_vzbz(mC@2A{f_i6(B^X<aAbqVaxx6jnA59NP7!T0kw)@?{&KmQAL
zze`|0|GK)3Zn4-CeVXn0L){zhD8<h+ev9!9ieF<qqU4Wmnc{aDU&*-KV8pjK-JQbM
z`QuG@PdnUF_omz9-@d=Ln){{O>)vv64c=nO_mtjp^9)8je9O%jY`&NCO4VELpmzL!
z)&0pGW$;$(rJMZq&}Mgj5`M>BV{kS7o$Vd+^FO;EDsD6QU6;P`?Wv~d=RUv1%{3V1
zzvt!&U)QVexu*%A4rKW=XTIl-Hn^EyyqWzm^L=-o;`Ih^ahnxyW_-iUR(FrV6_m&M
zCscmy7JuuPUqNRWecRk}#TPM-)PLe`S9~qwuJxa~F}^z(oJZ_%bKBvb^*h}BcKD$B
z&)ka*#(HU|J35KK(=AWpf9_T#@jrKStf0KZ>c4P@8Vr5A-D2U>O>EzYlHKkqgDa?9
zaiQ(!ub{gaUwQj(ca-8^Fs`|M55HdJ^Q-AO#xrjJiXV>>{0ie^>%VqiQ~5s_`G2{a
z3`YC3xh;aJh54t{x4C;1Z)1FB{WosZ3GC<Z?YTV!(?6I$xc*x=Cy7s9KjruMg3pI<
zC$G@pEmrM4e*G+Oqu}%$pI>Tuo0WeV<K1z~`%v+8#jPs;0OQM9ewV>w|2bur7l|1A
zNc7v@2?q0indL{6*xqc#zf(M4@gEr%)!W``#eX$?$ID0y>U;7m$IEGlr`-|pP7q96
zs`&hCRwu7m@n@X>()!NcW9{&$`l#2c_@HWjKdwIA>(R;RkN%VMkFU@0dMoyyx44OM
zj$kwXr`?g^ozM<nQ{UYi*be`!KFb^44$rA~y()vZn&)ZWpVQ0RWAHj!RO9>i057Mr
zU;aAk&iH}Z2Y5vWZ?zu1pXlEDK3=inI)e}NMk!v+ctQO^-dKah{}pp$-X?>g|6p&k
zV$pxF7m51i$@iFc#}Dx`4Bnc4`F;L=>=3VqV5@}j39}FJxWlphR_g)AUrs;7>#cY)
z<5OnmczKFvF+Owlp<ce?iy8NyeVA9M_&4nDad#f>4N|<>;3K>u#T)PC^X@y3@`@F=
zFn<5ee%>g9ah}rOyTM?o@8k9Ty()uI-($R0?f6UTkMSs7{QEbyr)+kfmtipKf2`*k
zEYFiKuRqqSRqUVNt*$@bqb`1alz)PkVKDNa;JF4%{$JOh;N>ay^Z%~?ByV6+{*%2T
zgE8Ju_KF45x7=Sh)t~H@CGqpUsmky3rO(gzW+(9nc=MEhjNuRP9!uh%;w@7C*@l0L
zw>pV`s@JUi(T0Djw<(E#n%AQIn+^XoZ%-1xz@x6df9{~!hF{>t1nYcxx|gf`Ul{)B
zUVak)2VSA_ml*yJyx~dwLT|M4Uo`weuPljwhBsCDzcc(Zys9MrnO=?ZKQsI@z1k%H
zSzev;on5|v&+=Bc<L{U-(ECtu^g!mnTYt9qvEp3D<4ex=GBTw8$1=XH>TEApaP$nu
zTjS?=dCKqfv_Ia@@%D7{<tu0i^RKBs#~avP@WqUM{>27Y(@4f!>d*0pE55<tA9|w|
zPc?XucZ0#`PlLTO!E`(G&#WKpRVDGy^=g#=I`g;IpX)Umyv6#E@jY{gdTyp~57sY3
zy_jN&=R>`=9)_QO(Qf`8@0_7tBunIFz8LCdD3<wRsCTj8beS)PdczGCd(SBw>P<Dc
zf>yJ>-SP9h`R(|3SDxoJw!;^fT;Q!S81HKoc^eJhlKwj9A5l`|Z4$mE-^VQSK344C
zKPs=h(2Hibuiu4U4}-T_{_}EEn16%vJN?7opIzjYDL$3)%8HA<sfx!l-W?z2%`mu{
z9%1~~yM}pH$`^kP^EUPrf30Nx-|L5Yn+03quVLPYip5{Uyj)l0#b3j`e1qYyVcsBv
zE9j7a`sH8Zjc&*H@eP9MSmu9Se~H(a#J|*A6~b#&eh|xFUV5pwxg9@!>7`!O^X=Jc
zt(wX4yYh0cx8iRm^Y5os4EIh@{NvmG=UuMw1_@60--lUTG14nm>_6YwP%+AjtGs;A
z^eS(LVtHQjCti(WX}_O%wTh*EMte<y^?RvTd(DdFdC051*Hqqr-g0Hd)n2P&Y5!}y
zJqDwHU*l!;^6OVYS8)AzOt{9Ip?IwE?^v(aV2rP^UY%gNmH8z#W4*Dx{ruJRAmg4(
zul1%VZeqOV-s`+_gSS|3FuwS<>%C2iWq)wJ*P>YZ%k^I2fxf;i>E0f{J+Ai#3D*8{
zy;r1I`pfm+DwUW1a=o|4VDy*ky$=nppvzg`?)VKJ9VGR=R&j>GB7b4!4c=)6V?8|1
zD{9B*-vjW91=D2CzqNjxw<l)owJI4OxOBWX>R`cAzwzE!#ZtfV-mbn<zwIoa%kpi4
zwSMEh$RUzn>NnmSDp=#kc<*9^QNQtCnZXrw$ya{;;@&*XFZRT}U5dq?xYwpw?1_7u
zbK2Vz_dXP?_Qbu96^lJ_FYi#17k|gSe1l<6+$%P?f<_yAO1vo|ul_0VHY*l;O1uvh
zi#;XY)Wh1_Q{v4KtoD?6vlWXyC0>=vi#;V?jlr;|#A|AYcgIV;)q<&%?R)T{Qg5T=
zSNkS-`G<@D#l8t%p<=Obg4a8@y?qnB9KmYe1h1cBv2TJGS9!5-f;Yur*f+teF&O?T
z^O`ijv|pLm`-t}TlzBOd#hx;+@yPb}lzFQJt374j8pUEynHM=q<i(ycFT-HiQ|9Fv
zjQ%vyD-wBY8vE<$r4zkc#p0idUY%mGXQDTwzvzFD<?~s7wqUhqqBl>m*fY`Ftny;d
zMDIg`Vb4U5j`sCc&{<#m{d<y^WAGNWXOcHnvDh=oo1s|jndDU+)83v*UX5V2XOg#2
zvDh=o`%vY@o=M)v2E(37UNleaxzN}%+3RPp@OQ^2dnX8{k<1_W&}5H|=N-84m(ICK
zvD|+-ed#R;?4Rdcv2;cP`{y~gExjw0zbe7^&x7t<dQSrT`5#z%ZvspH`QA`t&lc_9
z3%okT;;#i>lVb4~^N$sONql0yVD;AmZ?$6a*8-1@6M6C10xxPX{I$UAXE6HrL*CGK
z{N3?~yo&{^zaH}925&X<=jSsQdS#0J`O|&oVQ)%O{ztuXgRwt()SIpH^1T0}UX@^d
zAK_7No?`j_(W73CV)_2jquzYQ^1Q@j-eU%%eIN4{8I1BC^O{87*n8A7k9n(;<RAB%
zljI-wHn!t0Ui!HAq2@2;{?fSg32&F;l@0#<_k<TY-uLg;bpL&9AG?aXT_!kBu%2f;
z;oYEk&O(2@JmF0>81_Hm%@AzP-=;2l!mA1K7b^d%=lK2u^H+uVYm`5g?e+N|hWH;V
zf5$n(rxSepgYu(-3HozG{5<7D|DX`RNcq?QQ1ssr;+H8O<<AcB=P4iM*M;~^A-r1U
zE4jWaxqaH&@n2qA>%~qq?W6vG${VFv{Qr~}7o0Bb^^{j>@RsxkS>LNmpYrCby!5xH
zyvGcNzn=0I38o(Z@}D<-%4<&IKkaQ$elGJ@Ry^%}sQ4ttnI+G7Z3bh%zQ~K5WZEM-
zkokXDy2#5=d_Lp18246O%(%F0v6rLxI>sXy=P91b_}C@SdijdyFg}^_K!YEkhZwgk
zUE<AC{0!rdmezTjM4lQMk0`14PCMDyLoX{HEm-%@_1+E2|0DBvEUouillV)$?aKd%
z`P<5tn)v5G&m{M!8$8PQ_2YSrMlWix_;+b(qu1NubtLl3yqtD?yJ5L^n!y#(uZ(?7
z-q0lZCU1@Ksdt+{-k#I=tNP~vOT6#Z@O&aZ`|&!~@InIn@w#8bOWuZd<saYhve&BR
zP5z<3-(KTwHyHOD*LZF1<afu{dXWL*&(qnSin6s{j$q@@mbzEGLW8%O{&;#rvp34%
zExNvJ_Qncdzh~O)RVtSGq1judSo(Lf*J3dGYqQrXn9k+$UoUC)VyF1_;Jo!!k4`l>
zeK_+Mm%i#n1?&9ss@FrY%rCEc#VRlJ%d6g4gQdK4%3k%R7+gWs#{cWQns)r%@paxp
z!SpEe2RE!^e_Pb6Kbyq#sh*ahD-5-1RSNu)rvE`H@FvB7N|7(D_b)0JrpKNv_JF>4
zqTt{6-9L(apvZq*zMtQw(+ssputksyQ`83(<%jcuzf<coSM4u9OYHpu>8A-cQv&-t
zY!CE+qC77mb~~=LPZ-1hplDCzM>;6@C?`$z9$=_VC?{9bL6212zd-8owA%Hcp$^S7
z)S__xArC)<>kWVOQ~jXVs2}&2o}~7lp?dZg&+8=h5qXQ=I8yw5uIibTCj4;vi)Tu@
zP@9IS{F%o~{<#MUAASc#IpQyyMw@&N9n#sCkI=oQyfk`7%SAp=<OjZ9%Y9Ad(e9}z
z{EhxzY3gs2_`#v;435yv>KDkRqUc8ttDYw`Uq}4_b|C*xO+9Rqeg!)$LOoDV=tX{v
zvv5CyUQpPNek=Y)zl~5u2Y!dYp|48)zE~-6lh$K{p$@&PeAFXMUo`D*5#r!B&HoS0
zw?W6j&;in)!uf%vy=*!;DsscpeQFcpA9;TK2(YBv)WxLl9gha8p73~uzHT~i^ijRJ
zst0(0!46#&O7BQc<k?OgU-0+-Qk4HgGY%b^tmO-~=n1V?M{**M{%8^M!{2C+Wk#P(
zuc=<7|ICzYYdo>&edDkF#}aQ4j{*ukRqEe|w0<ZT{4hp)p`StS#2(ULz?b>kre&)C
zz+S>nl`ednWIf=}TD3>=Bi*9kX?lzLYp41P>7Z|^+#htleoyD?!8yJiHuXMG>=9}c
z_>$kI4>dpZ?N*HOAEw_LzD+%Jd`UdCD4hP3mYd#7#u4PvkAU+-{r0v(u@`cP-+ft+
z&Hq#3z2w!tqqY1W7-~^iPdML&Dku3Y3Xh{JRo{3+9hz=vgznOOh$H8kcw*7_lXpn;
zLSGs^ta>Fqh({<#%5_vOl89g6iyclPUFu`gQq|k26!D{@`5EIGROT^@!n8^C!oT78
zg847pzruRL>o>Fq%76c0>F2<pSQlZw#`p$CIbn?cCDcyT3mAH!AM_=yuTYzQr}#rd
zZQ5?ALm3D7;~_%1hFY|5KH`^6{<?}+nN-+;{J!-B<+NXq?MvSfqd$oM#Rl6tA2@W4
zmJk1f!r!3((0R057a7O<wkuV=_t#$J57s*<{{$@;7<61e=_gaQ9!LkR()93r9Ud>J
z_mf%<aF&U8HtjI`FNeO=eVD|-U>*~`o#2OYSiU1XU+sR<P@A4tjC^mMBJI#o+)IuZ
z9mlQLP5rrln)Y_+1@(ulhi%%dSoB&tKkmJMjCK94eiHPDRQ;%<el6n-{UtmOgLIK|
z68kxnhy9)4Kt4R4*Qwu;5BelMLVr{~?2-HyVIPvJ9?9z(i3k4q!%6Bl^k2|$Jp5G4
z1>f%netyJd>~GOO{;Bfq`F^}WdbugrrZPhvs#H7vTfMR#vJ>YkunXrbvJTq&`~`9t
zhw$$=S`S%QS&4Xy@qm30)@$MVOI)|9dvEbqn2-9lr~di`ev*B#O`oWr{$yx`eyje1
ze{+m}hs3WD%G2_|mvlaF()HAwqa=<Y9dc5xL!vKe-?08482xF9az<)-@Lwv5{<FUn
zcKLR;??2ej2({@MJ?FW_*kSW&zxaE9%jrlC^?5v`7wdP#`v&EM%6wr_n2Nq&{RBO!
z(j(m^zCrGI-M<2Zes!wIh06n${j^Q##$S%c4V-@j^B~qIICpzl{VMs;kM^FY&~N{!
zegF;E3;z5l<WHP0gx7OF*7_qI=K}v!yCQx3_I9X`p+P;u?TT`-uY#U^V~Zr6<E!qU
z-ZgeO^jozDe5~JqL9rhKA2ikZ8tgqz>j8R@_HWSp^qdp(Vxh_dqn@D2>rsyTdd>kV
z=QEa`1KEl5ADr93uKmONt7m`Z>_pspMdOzAONY)-zrZe}pJ&n|^wQBX9+L9~<w73k
z)9}~+QjB|{HvPrKS0_;}(&4|6YVQTwUY8hZ(}?}V>-p}1Kko{)>1xfFoF1%?5brVm
zF@6v)P|y9{w_UI0g(=p37*AooV4HAW2n@df&sG2Yw;1-IeK0O0uGu8#I2Hllr1io&
z0Oce80nZQF_upd7ThNbl*8dr7(M(e>o9;H$p~tnJ$?4c92ImxrPYo)+EJV?7<Q&VU
z70L(3dJ}$@^`u4cGx)&JC;ie+$RUm*Zieq?g)!to5r4z`f2_x$7xn#LD)9yF0g8Ra
zTGP%Bh4%v($DkN*h*N*mxP^33#3RuCjYGRtAId|1P>kz0v|sKUTl8Lt|98cx_rDZ_
zB5r~nZq8|K!ulWOgUWnh6V7|1<~|;ur|SK@k-Fc{I#AXxGxgl^P=jqc+R)$}`xKQ!
zy)lju=V3P}(toIWkPr8faejt%z&yR51T5#(!FuXbJs-YS=T+z%qV`S*r5_XX`;$#$
zL*--tF(H(Gr|P*kl>V5ehxLp*K>F*Ay01Z;3GZKFXE;4sp8agj0r`Ha-bX~fyMG|{
zkaJ~6*GCZ&e^`lmP3AXV*Q@<+sD1mZ2XfMGd`=tk1NdRuk$u7s+7bC*RsEo^tDoQ0
z^oBlu>)CW<j`$hn{8szvzU2M&Nk{phXRWpy@XKag@coQXy7>9~r?;4TL=yU*RlTS`
z$_<zIKW#@?e@FER+YLLBZ{K{2M9wn((r-7B!+y=8+qgab_Cfyw{!H6juuZ`56X>0}
zl7E-Vf0IOQ>UxmuyK(;|%!eMShfT@jN$mD}9P&dB`BrJ%6l#;S6Y678M|{LX)O&yZ
zAosz7@e{5W>Wy^RFF4pwp+4WY-nhSl_JMx*1=KIkZ+BPQAza?R(=9qo<)Nn|3cYho
ze{$$v?N_PN;g?i=ly{=q5$<P_kM9rZd3d49fu5~+NQh#c2U>WD-+yhAb9N`ufBbmm
zrziS{iElx>!QcC)f!ukfd^<6Zpr3V=FTqzoqThu5n<^dt3sd+T`r*f9YSTsPw<olG
z(6GKR{=WLd`NJ6V?|0ABfxkzn-Ov-p;r0mQ<nk;+eo)x)-8fY~D={vl9qkYXKj<&X
za!#TjAszNgKelMK&Sye{`}ESE_qGf501f*ij8Pu^06(Wnm-Vbgps*Y9;k)tP^_6@<
zdUCnJdJXjnQ`n94Fh+eqrM#d$!WeoW4|}9u7A4a_59$qh<OdD!PxpoWxQ_Bc5!avx
z6z5);-%xJyxW{}OrhCu7$?+qI7a0GDAK`wNJRgVW=e;rPMEy`7_z(REe8_iH4%WBd
zMQvUeVLYK+P~4Zrb1;y@yo~bwbibXh(zvuQ>`S!g?~MaH_LV=ZfA9QZ{eeELBQYP3
zVLN?&<JDdt`}(FC>d>8<KGVb*K1VXtp=la-{=0n_;<!WAT8^}*t?dx(vy%BiTthod
zQv0NzAYZUvLq7pUyMkVC_Nf*Lg<Tfa>OSyAeGXcvt?3TUSG!@y1eITAC_m4o{%X~I
zrK9`dsG*MXBb3bN``lWe@O}mMhWS!H)-TW-)F1g^XR7*!>kqm8^~3*E{iWXUU(kPH
z|HH=bHa)5Smv+GUdsyD4hqS-SxI_Q4bQ}UZ2|37z#|Qkp*p!QPZzM5J!1w*_->;l*
z&JAD>`qkd)m^Y9g{n(FpHb3VBJ<GM;FKYQnPtF&V*Q|1XFf`Bu`FBmaMaeYiN78R1
zv?WPyZ$9FL=z%{2y?%Lqobma-U$V_}G~kEz1?lLwSeHXT(!=#Y98Qj}fj`3Oh#Sf2
z7~erY^nZ*;P(0^|xUgOQgm?iAJE7;hu<sw_Z!foZx}|dbJW5iz0hat0?KFIwz6#07
z_;$#S$-W)+KzdhAM?FCiCy);q^2vGvJE7OzXL+gRByL)S`0|!{t~ZF!unQFO@E_(a
z8P^dy*p#0}{nQThgRtE3DktNyQ)2yoy5<Ydi_j0fsraHVEujx`KkPs+?w^St?7hw@
zFVOtOO6QvWZZHo>IecG8=a+DOVfX&}Ei5N~jU@b<svOiG<M{jfAM)Y{hkml3euF*I
zPQf|>?FkCGaC@Y};r2i~g!N#YNIY{A?FTuu2i8~cuf&^R-Sz#_Bf2k1OWfB-JpF!p
zf_S)p_Uv8m_bYGj{I~GB%AZHB*Y@`P-X6=k%1*?IDJmDHKjm~kAKv$X9$@U7a33I5
zyUprA&)r&nnELtrb6Dv&7CmIvi$Oel$J|E=)(Z<%9{pmEk+<m)O^4mE)Ay7AJdEg%
z&?1#vZfNivDdfZbao_0?I?Bx3X(W2A#B*vG$NSD_5#ll^#u@qp##O5PsnVej;|=jH
zmHz!LZ-3iAtgj=SsvfD*Q9r~x#0ShX9nDW2*#rGyn#!L2^=r7?us_4)0ZSb0czz1U
zOZWrxS4VuYFLgQL`6*oQ7j!(Ko~dw0@hX*{VITBkd?jOt)~FrehwF`aA@LxHixO|J
z&PANCs9vA1LR><e-QRj7#~pr7N#o7ihC1}Ip%MDZ(6mJSL%sHIUP(0%?LA+F&olo|
zmGk}d?ro=xk5u(amA<#0|JIKGQ~4+AxyN)pXZdf-L4ODBcCgH+nM%v_yanf$LNTB6
zeb7RGeiZ7j18|-Qxl|bKB>gnlx8mG$-|3OWeb;@Tzw&vTo=;?{{mGP{XWwVKMIsl}
z3+IvW1MCF_A6VKU=wC8^fkAER%jNs$qyF=~p#I7W{zrStzRyXVn<1{F9N<^9ePrEY
zC)OwaI_bOCWq2L}^f2`c&ND#~zaST;$7(*vfkF=ZN6_T+f#7~K{D^j!b3dHF1?PJ3
z6Dag<(sM=0ZzY~n!1Dr~L;E-6hrOU!|AE3T_!oM@7<S7%WKkGHAM(LYv}ZE4L+7D3
zeQny=p$D`cr>Ngi9_GInPM7g`W(xj5O;0`-u?YI`oaco}`E43*FuxCNXoSWl>EUxh
zT_>Y_yw4$&&&4(W&HI^ewbo;;(q=<#+MpQqeoNEkJldfa<)=#jO9y<|jq>4FV9>v*
z9$&sk51VFiy?XR;=pL;f{DA)VfJx`~7nP6nTE+WI<$T*Ftn+c+or;Ffca!hiW50y;
zOK=|v@lBq83*N5?<HR|f`r|PjhiIR$JjPv^Vt*J;?+AzU0e=&U2e1?49Oqt$w@43{
zhjAHBNBz)0z(+Y4UpT*$^x!@R;t0y^=sriPc!>CiI2ESHX}kb^TKgO9L;Y50|9mlt
z@1GC&@x-B2=Zv_2{u|AgilQ9Yi+;Fo?9i!dH{@g;;w0`XA{}w`|0MR$i(!9qImzk%
ze2abnx%T;dKKc##xbN_e>900n9uvRdzKx^vNwAKPcE<b|oJ*p7loRfs`^Ld}3Hn8<
zevA6-Z@=y6{v75>sV~>Z%p(!KZ<m(1pND#ZqTfir=5rYBe;8Mg1BJby7$;Jn;648D
zi($Xan-0l&QqWGAPyej;;k_>8L%qdMd)FKFfxTgh`_Qu9b_n;UWPO~Lc#bgnxhyBK
zjz)W;-m?D>)-UL1c>W6I;ki|;oAJD4@_IXXjuPz<=3^Yla{<9~WGJVjdWGeroZxw4
z>_f0$NX8C*$nE0a7sS3HnUDRAt<NVrB<G*0<iq?lO5Q&OdXSFx44<n4!*8JB=UF73
zpC|Z%#A(zM>GJ%Fqx`@x@Eg|o;rp|xo?pPaK&VYSwO@-K*kMr^qn~WnxQ=-e{SW85
z7@r;OUphKR!Tt#PFyH&wkHc6WfDekeiTYu@N_+8rKdmp?2lorXNB;&N?<GY0%Dx&H
z>r7z09~H(2Xg=vDHpLX@8fw!CDKO#?sQ4rJ-VDAwgZ_v9h3}=Eu6ku$2G6ZS4)=$#
z-ji`-QF8yVDEwYgq3T6G!8QRy55^(NLwfu3g!c1o_<SmyzkNRcyaITz+5@}8>(wxZ
zT#@F(IFj=CeIEVZ59|g_B^ORl6~DuBqBj`Nc#j_CU9R>4U#S=r>F{e|jvqgQbws#4
z)a#m%-c)jO?i)O(nMw}nm`{M=&s6>h_gmBl^!w_8ykAd$y;q|3oTe1-<^SbC-%tF#
zxg(SP^?l1ldAD`o&s6nK<TvMUxc?gThZ>{TrkQ#^m&!g#5AsPn2kY2JRS()HjKg-I
zpGbV?b(QYJP<|?k_1tnTue0%U&>v-AXY2dG!MgjX!=ycqHx%=Am<IJJP`R+(sr-y}
z5905>u|q4h9qaVH4#)%h_euTnh4f?`q(cwn5NG#YZjev-fgP#jVGr~JC);CFG7ic~
zWgqkj-$}ebg7mO`NMEad1AgFG8CSr+HT<Anf-Mqilf3^HV0n+hA-V4xq{D8ZHodLo
zLeJll%8AfF_mdAhU*>V<#|`HYX=jX=EQ4)2SkqxgKgF15#XtN$g;`&qzLCWGG1a*F
zzUfD6xmb6@PQez1(^0=uO+Nl!gNY{*I@jPd^6O31N#kK>wKqzK={Wel_CX$YT(0(t
z9Xzh}{Sx?5-fywZdvfjPFX#d7=zSQ(y{ol6#CuSzyYW0Y*3EI1mv|EFcMx9?55dQH
z!@QeJgE$2_*fm+p0fm2lrs=5X_oc8?>_ERmJ@EW`u&)%q2m8u!eknhah=*7QKX3Yj
zt@|e)mpU(jBF^Eta8R^+m}313IZ)UGKQtcU_fMM^8_M-FG(xKlO`}&04eE=0;r4zD
za_aB5^t+6p$cN{mg$C`3?{Q|Db%R3}7#c~u&y4q)ll27op*Q?}-sJa|ZMt9W!??xw
z$Wmd*V_hqLwCPW0_<pnWdzJq=#{L1{8<hG-wEk&{`ah<27npKwdRB3xp}}{kCWY2r
zVR^y44+-U4sro)TM*71VgPp|pt&lF`El9`v`l1i%{9Pz>e;?m_u(iCs`Kye*Tpw+B
z*bh7ZGyN8=)B2(P_pK+DeL*_fMZVV&u9rpf9S8mns`@XCll|-v>IZwI{^9lr<izi&
zPap?9Qcp|u@;RT{@qPU#<)D4S`W$N0eg(TzwfDQ~cYN<nXs|BrljrxZ2<=ci@f{EG
zvqhQuT!{F^(eLX<5`Oz{^`jh_r)&~?_&IR32jxpW9g1l`{%^~LA5d>Q$6p8WcWDjf
zatw{o@rDNd590{qFYI^pgO2){=n2}fBYmiM#KZ%9SInkCY9Hns#AEcgR21_x_!3`i
z0!F_Q?9fFaKcq?@W#pWY9{zrwes>DvE0uoKqa!=8UIv9c&e1?+-VMGJ2ki6x^)L3z
z<JfNhd`9-k4ox)mh|sNCZ}4w5&q40ZZ?D(C|Acl4r{jCYvy5Jw?laV($Fv-o*Es$v
zhP>#p^!uQxzyFDK3Fb%m^BX<K1Qu!&^vk?w5$4}8g?y9R`?8^t#Qme+tG(#QSRbI=
zKN&us%V|FdV|+Jwv+Dng>O+49#rybSihA9z@!>Nq?_1S_{<gp47xh3pVm^kRaQ}yY
zmYMP$eV#6e8)13T1HPrt)$aX#uAGND6g^b-X}BMjoSypm-0*Y1h)XCx89Vx%Z)C6M
zeE+BPpq*0rF}dHSULWGSZipx7AE44+Jf9f9Idp{j?^r`^LjOr6C;JOL=Vj3#&3B>d
zyG`d`v^&0MCH+14j@582SNfAh9Z`IT4E=AMmM3us`E8Q>0}h4Lr>Xqyp>nZrt1;<Z
zFXjJIX|tx|J`c_*&|dJjKOg(gf&EV9G2fwH=$}ZJ_OTP|1;lBze|Y}H_yk|{2J4{k
zdM>>F$2#+0Iu5rR8lf@z-cVRx-bdr_mvCJ7pNFyZ{j{*$pVd$Jo?e)bdWzk_INEOd
zNgAD?dRx_RuNgl&B<&llBc=U=^(NLSxG%QL<d5h&DJ`*XgPg=GN7Et4^M<Yiox>!K
zKpy=K80#*qi$H}R*eU%Vc19BO2K2xVtS`lGe0Mll=RscjL7-pK`MaKGeag@I7(XID
z2LA2HujscjpExwwv_r(~qrR&jV_f6@TDV__`=Rs;o5rN*KiS6b{QCpu`@O+B8skQu
zf3vBdk#iFJOym>3qkKy#^aXK2^auL|>3<es{zAM*yYKIKL_WlWj>adR=L`EOjG^cI
zu7?rlrCm9m8@~r}B31gS+76JHekJ|EKR*cb;ipvT(!YXp|5W9sN)PM(Z|%W4Zm5oP
z;8Ya9M}>76#u>(Uh4yFkQ}hG)Mbd35*76{Co%(sIp~3k!eg{SP{OhEKA4$xM(jSBK
z6xf6F2(c?d4~EJM+m)*PA^Lt*s`8Wh7A0fYi}4mvnU8U9V(I)G#I26(57!g(=l+gQ
zj3e<wFb>c@vYvP75%rtMWBr->JP7mYcgv^J)A4x>#&Nycg?-yE72|u0e_)LLnZIv)
z-(cRKasRZ5=RuX1dD%+rYoITg+64Vb|0=0GJMrD_@H{W;ieS9s+%Xl!`T}t?l^pDV
zoQzkjKl%A5Gyer~3Ve)Hj7O}WG4Dyg;`<Ofe?kuP8S<mQ`PlcftnV<t2lvx3ABN*N
z?sK6%{q>C>Pp!jcy@CB8%01AeJBjaZA^i}QPsR@QPmwNqg70^nqI%_=BtnIue3I_a
z`Jwa?A&mW1s`N4=ADo9L+Z)&;^>GMxqMgzIaDE~AE&8e2QLXf0rAw5ef8f4ODvEyh
zn&!hkHd&s(7ogwm1pl{29?yL`8prrO7Sn(DKFD|SgXbUjPp%Wat@fe+AdY^&@&Y|8
zbe)fN`bVlCe#3Z%Ur-+MVc&!Al%n5)zt!mH?>lKZz>w>y^NX}6p0A7~`uQj7KlCr`
z>-VHc5AVD2y=9@c?$@2Y_Ukh4U?+bsUF}VkF6T{lLM}a5&O?!}ufZ0{@9*)-+1Tq)
zo=NBXtICId!48d7ewF^72Kb_vpFh-m_ZVu^6N)7t;!Z%}cZtJ6KNWvkwD0r?$+%BT
z#Di3F81IR3s`g-fh#pJz+4QR6<Ge3I;<w;?+VVV>Md&B!7t-&7aTVrEeIh#k(h}nj
zau_eb(3>is%sZG*`1cL;z7^s%Fvdw3zomWv|I!rwT;gJIpG@qs32|Badn9o_3VwJz
zApQI1L%ZQSGZ^nuAO3Ef)&uR2`XF7XO?Zwu*+1}GK<`sOJZdPOYYOf|BF<pGMqCQp
zwbbMf^uk`yj_iOO)`5ug;c~Ffd|k@}-l+B?J)G}T<G0}ZnJ5qb3(JT3sp^gS?}HBN
zzf;={dczd$jpxDPudrRX&%Imgi}9Q){k!wyJA^igzM$P<AN&KHiiX=QjL}~uJ@}o8
zROzYeFZuVjbC}*|9-{Y`!u7^{h<=6s{H<x1z@BivjxgFSEQfN!>5xy=pHlgEs@89O
ziu$3Q!sQ{o#}TrQ1;u?0tRJvmf#30*l*DI?HfXtsYXt`L`IgZep|=fAqxTH$lz1-#
z`i{}^vA)NBp8fr9KKA7p@244k*jJ?5=LY-obaM{J>qWB;4E6=spW=K8{Wf_Y8oo~-
z-fwoiPdrcSkA8=7Am1g4s9hbOv*NrF=aX{28Jv@1--P<0-qOCoz8d!tgzu1?tMfX~
zoX@5u&b#4v+&_T4=nL+nx8HyHJ1}3)-{;CcERgf{`1>=_>!@5r&tHOd0`~n<Ua)?`
z`9JC>{oAI?)xY6=UDzM9jGWl#-{(wK?~dx*Q91kTU-%8@KZtK(EPmkikM?`ygCD}r
z&3|8vaT(4B|Kfeu=hc7f)Zc$nig6?7GY-l7%n@oa{50CCa)<}}OA#laAJ22iIEc_@
zGoI6Er_tXjai1dDf5CW1zY33U_!IdAJK9ep^l!EQz$0Z}f$`hV;NaX}<oG**<~$}s
zr-k^~XMrNl;=M}53B*}hkMi>fCay;4OB2V^=xake(O(ShoH%b!6=(7O1t{L%xIpbg
zx;#gL^RVFix`?}Yeks*+W$3?`sa~vSk-oq29&u8h+r#*`^*J`&=MVM+A{SseF9Z(O
zwO6QJ<Ipbpdyv4O;c<|DoSX*<<?l-D6Z7{Y%=6R{dd<)@dfw1Z^o~Afotz*2GNSp?
zG+!sp*Ex|7_dmn;b<4FLb3=52V(d3D?>}YIgMBB)b*gs3{1|=?GK^D=XWXYoe1Sdi
zAM&BSrC;&)LG-;3Iq!1_>A2q@{M6}^FS1uY+&7W@9rHy`T0#%(LL9<*WGcIo<vXrd
zNA{uK`&+-T{rH_$_*3|HqJF3c<bWX$3_HW=qHphZfqdBR{q;}y{*&Yj+7JA&f8?Ap
zXuq(W@KftS{lfXe^#C9Bgnc5ncloL0#GX!x_CWcfCupZ|d5}Z8$UAzUVDI`#IYB!i
zUn)J}blBgKAHWZ{gFGk2zk_1pkwa2`BynE@>yA{<rJ&!Sp0H1FYCj2o@B5@OzXkUv
z!u>o|KBU8c$$r6m-4=!8CHCuxe|X*;I4qC*wBdBj3%}EN|E^N;Pw;zC;e7JEJ>n5R
zC#&b<vhE1xTdZ@y->Uk@9qiACHl@Ny|4-?6>v!l2wFCOY@~A&3o-62xrX3~wWbB*6
z{=o0JV0{Ms|C+q~ejVBol)s0gze9t1h3kQQ$^77cP;&l2ANnEIC+NqJ|Gxf7E<Y&e
z`=(=E1N*vb`y#zh5)PiT#e1hX$C2N=#CO_*^P+wx|K9147e2=~vz`fl*Y$tPm-Y1j
z-~BKBz@}mPTyZ!~qrac3{Z#s|P02X8pZ~x8>VNx{|J=g=t#Kv&(kAJr{Cfar`t1=(
z{LcLkwI4%H_)da<f%4Jsh4Q{XlrNQj#P?#A7i#N!wiW@8GJGeIj(j)lXE~VHknexT
z-T#ie|C{3u<7ATd-(<}134LdJgk~xq{U7=9JuQsaj>etj+k3r;aRS<rKIp-F@)&Pn
zihbhUYCqPUpkaP^euW&$OQym5!26a9_^I;YdrQa<47$Ut$AkBwaNdpcGOU}ikHI=N
zyw2V?4!+BQ^Iq&TA2R;3X^Hwx^y7P3c<wVe|3&}#waSMv`c3$GAGyC}@AZ5S`~f|u
zpCs`^DF5zs61E8Cf{*W)Y}9%rusILsZ-biidYhmZ=byj_sD6A;Dwzi5C#PHbdo=+c
z`cMzp8P@+}EiWwBk^Voczjr7_c|rp_mYR9iBB4P#?1B6q)st)Nu?ZOd>&PC=b3#+E
zTVGC5-~TE5_t#!L_hI$(_w^1%42@8Rq5Qi&>bKsC-%z{JKU2~D)f?8IO5dAm2fico
z-Q!%wwSONK`clc`z78njK={5-s{G06h$lh0(1*Ap@1xpusQMH3;eB0v?*r*_pC#D8
z$nUrFb9}lV>Ig#*<mPpfIFg*szrSnJ`Mvs{a=x>_aSHZ@<)IJ1H=m4y_j@E?@OvX+
zJwG+|<o95-zR5VX9@KB{$x`3BrwPS(?v8f^f1&l2@7>vSntm@0_hE((5INNIDAR5>
z{X+Gk9L!69QGK8yZ_$aN_C~%i#eL4OJz<P>2cDn5D8+Z)!uo;bIT$=AwD<Fjs4wKh
z?J_J~{30~<bE?RHtojQS^EPN$f2w&A?E$@@;qzjoqdd@)wH=@bRK_unE9HkV<WlK{
z{#5kZvwVNqR2dq7xbF)Z&M)~a3a3lF;OBbuciIPs`d3&U?J46hXzxFn^#H$@mK0C;
zJw6?GkQcjcf*&v*!*alogTGQy+~<e9+z$=j0|Y-+ex!%nU&aT2C;SxYrx-8tTnf)?
zdd`~)V|{tG`V|!Ky_INsDhhwYKF}-8{dE5RyrKMik%mU-F1^o=^*FwR1C00eVHfm)
zhR^Mho}tfWf1@;4=`wsTNd0qQFYy!NBjiC5XZo_8{=ACskcKhJ1x>{dr$b+=e25cx
zE)V_%O_eWP4xax<eb5hp!*S>(jpssB$GO|h_~!REbsV8z!7kYO|0*4+^Wz15Wd4sE
z%<)ju@6-B)?T0+ZZ<r4Zekuw%&{T5a^aiyTG|UfUv<KRCy(e+`YSkl{f8WTY2kWjr
zX1v%`-c_F4Lw|)H*qyx2+55W>(2H_qp4<EVj&MKRt@a2_-49Ve&}f0wueYIi4$~s}
zy~*G^w~+6M;=6J9t{J{hh2M|Z-}DwUZ$%Qni-K~0r0=o3rSS>t;@dRd0=xQqr}%xI
zeN*h$9U7wb$M+WHd$9PO-(VkKrR9X_&rLetH`nhiWBz?W<%g&}o3tG4zi^HrzcUm3
zelF5Mu|Gh(7k>o5(;d#AN-kCU!)iaiD~{*Rr2OFbJCGixSeJ(7@!f2EuUej$wkWy&
z!S8t>Kl1In9DXu3Ci4->#qYGqI17IN1LsPMwSG<79{7Em{rw%2|5olM^SyJ6DwHDr
zhbj7v^dqjP&KKx6((X2$og?)xR2tr&qQ4*=6ngNTNUUR@=;P~i^!vNP?^Yon)=$Y8
z?>~SB`&!6>VxJq{H%qy}_`-KaL1FK)=6xlL!rwUrKTI(W!|7rCEA1DM564yMKYY%^
z-(mOtv)0H5?~}c0a3|VrXlH$|G)f2b_vguUDl{}W&;9T8bkX<yy6$xz*pc0MUls4M
zh3l2fPt$Tb?Ntu^7xr87IY-bBaDD^+FZ7%S?TG%3_>6fnOcDRX6#JNe>-q!x9OTD(
z3(rvkAEfJ-@VYGQ$1$e;Y%0}uOvb6t7sBf!tb<@zc;5Y~>W6=QzobzQ>P)>UN-@5A
zQ&;Lo8GLo)t2<wrl*iW-eC6|X8ejc5M?cD<r}@g`>j}Q{`8tiSm3;N1p7b(bPxF<>
z*Asl@^K}|uEBW&I>*xR)&ZYIEK4e>cm>xto(7`N!Fr9B5%(4el8DIH)^`pKtg|9rm
z&bRt9uP^iZGOsWFh;ctUgf6iTp{Y!#@Ri5c`HW9vTE<sCUq52pk8-G-uS={Pmd#<=
z9G1;t*&LS5Vc8s(&0*ObmOYB*)6rB*$MD~IRL568I+hyws^iQ5yNr%w9mg@}IM#6-
z>p0G&<umO^$I~jlrtp==*ZJ1*%s-y_$8#CS(_F^==tTCwNwk`;ReVk1E03@9t&>>x
zB$hpiWlv(+lUO#NHqZdJdjQJ~V7UP-H-O~^FlPYUJb;>*Hu6=+S3kbW_}a+V20E2}
zd@83E(1$dT{zN~ds5O{+SVJjholm(|5#?DIvMm?UY1S|rXk9{s_!?+k%JfpEKc<VV
z%jgyB3L0yTq#O7eYmK78G>UpL{hY3(GV4mlS2Dhm@lR-~bv0F5V_EK6rq|PaYaB(a
z64qD3`bt?}8J9Pad6QY+WSYm<SnFomWKE?OYZ}{nD|NSSWm-<#t=l>8Eb3w3Nt<ad
z<=PL@aC-rbwx6KG`1+g{(_{9tTz(xbvg?@Ev+mV2$NClRvDfgmmV@eArt6rlW4fMl
zoZm9tK>eHzl*gC<_sgAsPx;P9dfeJbPw}<bdV}iuT4w!`p0nPhfzF%Edy{!@GVe_q
z#JHa6GQNiL-@Z(tvx$oM8pzk<)+UzS#Il=Mb`#5PV%bebW+>z5tj+W=U+?ktIlWJJ
zMBk@-__~)bA5U?ZTJO_t>jQcq`T_GlVEzZp|A2WPFz*AyOS3;<9gJxU(=AL}S-zF!
zTUox9<y%?4mE~JmzLj?Hm1eiHeXVR?E8EvfmCS#Ssh{_e&L7e1(T_OqN1XQ~PTNX<
zj&5b2{f&Ov`ET?|bQ?Y9Y^R4hZ>Kuv@6_b%q*Z+RbTwZ&&gZm-uT^|C@wJ+-9OnzB
zUoicW=`QB)V*W1X@8YywbaeVII*zZ^&TeYvYYktk_-f+IPs?$>rdH=)eEpktI^Xd1
zE$!lK4_`YS%c^s_TC4bK;;UbzyY*0dck7Y#OzY|NENeMmE7N;gy(2xX7+<gO-|P5#
zJ>BDcy*Rx$r}wsQPVa4fPJLKUAJ%gs>p9V~yPn8tCtJ<V$<`XaR`J!u*J{3UoP29T
zB%gWt%*$t9KJ)UKm(RS@t&_U`z&fStS=M&vEUVQS$g%@jb|A|RWZ8i%JCJ1uvg}|^
z8_a2gIc>1P$E6Rpj^=B%b1vsQm-C&=GUu|)xh!+8NzZYHFmDL+hA?jk^M){Q2=j)p
zj-l2b`+O_U;pmojzC}!ZoXdX~^WTg7biV4G3pn2eobLjz?*;6O3)mM$EPJ7KLfVB)
zhgtvVdWmIcTw-<Ss~2CN)1}t^)}_|doiAhl<<{`D%ejopxs1yhk7PWO=_sb7m|n^B
zN~Tw_Emtx93CsS3>1d{-nT}yPhUwKzuVx)r^WWDny@u&nzOJ?ArCrPPI@WU?({a|d
z_IQ>Z&wrO#jcH}pP^Zj#&MLE(@imwxv)p9nPi7sHS>|SIQ`%IkC2g8@bhl|tr(1VK
zr(5^%buV9^({$@`Yr6FmUyH4B{=1z2F6Y00YNgpfwcca;InA)z(q>p|otajoQ>B&B
zX|9#q>2B+ZZq?SnPWSS4pY?RN1=i?JPceTn^Xr-SoVBsjN|sx1<#hfnUvKdBC%*Pr
z>$=<a>)j*vpSyRmcXsY<|Gj(Ez9$;B@8#=r%C^@!uHBaAGVNtgi}W(|r;$VL!5r->
zqlYm)oay0AbM4vDT>d+k|2~505loNdv?KZNBl++CO#3rEn$wQvzmMj>k70TY(-Z7f
z(Ua`^Bl-4*=m2{oUmK#Q@KwOqK)Wq^4qt;<ZZN-wH<<rEm;XM`&Po4~Ju~xS`(f*1
z`#rusr(v9ai9IO&5~i2i!_%+e>q@@H@O6znJAJIZGIOl`OTJ#=>vI}sSJ933JQ{D;
z&?NhHzFy|*X}<FKdV;TfzE0z7C13scTF2K$zBbTgdo$f+f0KEu{U@4kN33$Yw>8V|
zO?TRH>rVRyzQ$U!8PDNsE?;-?Rc%*U_cHHZdmdk7t^3%{hwY24N9;(aN7)CDGXF8V
z)OpPA&a@vr%X%AF<|X@L`z<@q{*yh`e%o%dHrtD=5A36}Kj1oSv7^pk`1*+Dw(|8i
zzCN{|jecsM&2%t*VLy`og?&}_E_=JP%Wif4X<wJU$G$PUt8;UDSB{2VoqL#`&2%tz
zbMA?DbMEEqbL#G#l+m5jyK{QBb4N6rdD+a%W}fRDX1j*o%Jgi;gURFT0O#gz2XOiU
z&aF((W;&R9b6Rgs>&<DsIjuLR_2INWoYsfa`fyqwPCJOx4&t<fIPD-#JBZU_oEGD>
z7^lTJEyigFJ1gyjIqhKQ6z5=0JDAh@a#~+b>&t0<Ijt|J9maVN<Fvy#?_r#F7^mer
zA4ZRGcJal1)7cX}%GqKa#k`Z9b(tq~+R6O)S<X4xXYt=>@!#h-&qmKNbTG|}JaZjU
z?3NzH3G`OnrHhy@owLfh=scpXx2$r0Kal7!rsGHXa_RID<7eaPwB695RvXjqWd(FP
zpR^Y>Ore3C|1;+MdUnS*D6Lh!m5N(v@MT2hm7Ay=)5WDt^wS5q+|mlFy@zN-$s9U^
z(|5;fHN92yS5re9QE|g|#m$NI$(--HhFz++P4#X!`4^WiR6Pr*`~sre8Y=1Q$$ojR
zC3Y^O6|DE3hQ+j&>6Ul_y~%V$iED}6YHA)&v^Ab#34OtoyJJFG+RlkYFV2WrQlC6a
z>XU1I!1))K=33jBPN}FOp%GKw(m4gx|4E{+Zz`ZKnLoZHV)^yoIk$igHtCPk5zE95
z-`~q`x!CdTuDz+r`o|B6PAqM*{>JnurVAaSTd!!c>_J4QlrB{LP1dhD{dP`wIlYkU
zFYQ`q4Y-hK)I>hM`ZrNc!+MjxfN3|zk2N$~{*G?`70p&BrZr5z7)ms{bc5>sT<e`{
zZ?TDfaYe4Z;~b*5OI=&^=h}Y1`AuoA-HYi`rZJ-@*Y3o4acMv6LaxUjC*<0vF@Cu;
zV*i8n-=VaO={Jn;=X@`4y=QVin$7jx5-&9RcgIKB;^(op`1u{8*Vw=J7uwQJmURHv
z<CzA_>d&;kVUXHYO<P#ciiRS^>DH;tf4yOf!5bUORevArLQcQ5^ib<+rdt}SX*|=9
z8{%4SWun|koc`*fcW4gNZyMgA-ep8iW4YQ<P1Pn}HO*(*rSTnloaup$#R+>}U|ih5
zYoE)BavG~NeJ#Dj>Elb@q4i8hFl}LaL}LMcX3`66zu(+6{~h|b!Cz_rc}Ho1?e`y_
z-{l*kV;XxKe=nL)V?W6Cf4`(z%b6c(;BkNJts4|?Qre=lRq1x6XX`jQ+d72xURQCp
zb?wtcCo~E^p)s8%v;OfVYfb;y9T&P|g3vFNel;QH_;(mLUlDWsCloFl8FQ{<TEz5b
zro%>-OFu1*ISY!|zOtBex1rT^G?#m7V~z0V#GGGodPP~jBmJ(>(B1Ju$3IDU;D$nH
z$VWuer;Rgq4{EH_@jl3Tn)~DCD+W1-bS5eoImnsG_z#RL(uj^{{0!54rc1e>{-A7-
z<M;C;n12S3n*}AK9O-AHw7mW%uI!GFRXo<2TF?D^-dH0SuPC77+3pb~1#}kEDfd@X
z_Zx^V;Pza>{dP-yirQbUw3;qtx#5jl)Q{yf%;Ybp!r}h-sV2YQOqx`s<+1!jMDfNd
zN8(bI^C8En#TAu~A2()IR;j(!bQSBF)>z}n_*v*^+;s*<*<T}@jlScb-C*eH&(=8-
zkENYwHMXdIn>7D+&EKl&Wof%O4!%93!1nunRbz$m`;H0KbPbn#Z{r+m?i9a&6xcT~
zzO8B*O)~W=un%B=JlVKQ^;A<Or!Q%YM8r-vB6hYp5>FSC=xK8#o{qMMUE=$rn&xu8
zX^qwN5Yu~^K5B3QEoHj0u_z+_WR%is%O6K;8mq09&-v{zR?`=l^w%2~STAtCE%7<l
zZ<uasj43})?TV{ixe;yei1;hl$nB2jM*Myfub86w%9YkAU1r6&+!pQ!@3Q{Z#!5}E
zrcW7v%J%=8>9oeGL^^N7D6(vdDJNc0Ytngs)bi_0I?tn;-W2IOfT-cxrpWfc5nWzd
zr+R85pBTF~Xuf8po0MOc)_D@qCo@_UOM4u(EZ_8popWXWf4!uddaykO%hIWw$Nkp$
zF0_-DA4&85y*r+vbiH+Tm2by-(=WD_xh8$-oIIs%ku>ffD=RY6`m)~hmlY<`GdSJX
z<M)TlmJLdi{xB#_)(O>g6w7yMEHeD^%3|fWMMO_E9nbt}joYkKn9jc~k|yJ~Ei%NE
zQ$QCnU4Baejb=J}*%U3;vTtO3-LetZAx{w<yQDmkK9SRJT4vd|GA(C%C)3$XtC&8>
zw1(*u%L?cbrmWY#voFyjqYCULjF&7cu%BbPHC|;)e<{}S)TDMV)N-oHUsp6Pt5aNS
zD7SmsmE3+)m`Xg@WYTxXhda-6eE8K(tty|d^VN3MEB)=;>6^6vkDGPIJ2yRU)*<iQ
zbe_G2?RsNbTblIeHX|3WIL}_k>GN-UoPNu+xNMH~9#el@e8zMuQ;XlS;Q7h&=bg>V
zmhs7^#c{5Ha+v;QS)`MUJ6Gu(>ljY=*H>pS{dCzd`$DE)GQG;sJeA8=x{TtSKBDAt
zn!&WVY#IGR@e54%u)WgH1{ryd|AsbH4(cTBT-ZtCVqvG>vi#!G8WXQ~&K=ar?@zS6
zsFU=kqE6DEiaW_VY?+bkvV3eO>3?zUUvZTmtNMAJXzVGVzZ&`m?PNN%w7}*g6Uth?
zjJhx#QL>EB?Svj~Xr(E?ys}*Nt#Ou*;(m4u+H;NbYsSHPe2uQh(SA)@Usu<)O`RV3
zl-FxZS~Y#U($-G?e6zBm)!6G(8E4x&Njq;h>G6tKXKANhCZE4P_2be(%OjeeXXx&D
zUT5)ZUT1&asjSFQep{z<(=V&Z@9#$}&sX_A)`?u-OW7a(ym0*TLX{t3ox$l>+*D!r
z<$mkaw|-1CVEG{B7c1?r>HY23nO|Ji->xb4<)_&t98ab_T5bBBAIHySeFK+IQ+-7y
zf4riov#)<~X;J6-#=gZQ@m$9Dxy!TcOF7@^OZw}&;!r*<vDl7Lon`(h?=1bJnkI7k
zrOOwpUDbU4YH{4DR9vI9O3SV4EaSAQ^Rry;;?g?hmqmVaEz#k(MjU_L%j;c3dHw6i
zx_5zDZ|#mpqS782N@qv9UPm<K*4dGXOh@19YWi^J39jFBH{}}4^G;OS^>L$T$ArA7
z^yfj!9~AZPm^6$V6!qtYA$57GCpRkdRgu9b)fGkkec@Sk`O2Rk`NgIFda+ph$JprF
z>xs6Njg3y_^rfY5&@A@H&{CQAXWuy`>hBj9mu`&Q$Nlf_=~b#{W8^W$HPf5ZWFJzV
zNT0#!lcv`i%=22*ze6<tirVOc9e)2s{@Umw#+fA>BYytlrZ=g4laa5vqAB{%B>ARj
z#@~H;l-I2C%|`y0<C>#~GC$D2G4hJBZ)4=oA-lJk^cKzEqUE(j3zG7;M9)tuZ@bEG
zSNZMHkxBB~qvMn0+f=?S>fhnN`HHsa^d$MV=+BLOM!LkkjCB9WokvDxq(7OYC#L*Z
z`gw*QOZVU4ec-BC`tl^X+;o3_TU=VG@`dUC6R5XdQJB6qsa*K4z&?ikuyFb)BhPWd
zjO)?MqiMwJ&aSt`(|^zFflj66s;@k~oXh|1xbpO`S>MFED$Q4`{5nG$Dr?g#S#IOF
z+Vu3#h^E#xsa#F^8rJvElDc$><IS3{Io<CcygyApYM=5ORBl7M|3q-ZwHwk0>{D)+
z%Iz|8?~L1(e%?OiVqL`Fu`a&8zmAJ_xpJR!MJiWh<aUlL>N07ca+NAqY2>~gSJ~yx
zeac1C{Qcn{%X_44WB(4nP3TW<Td4V?X$Nq6&)b?bel6_sNmu>_j2jnrS;+d9mTuR$
z6QjegB)aRCX3f{!#c$_6H?Hm??cdzxS(eW%sq5nJlY5r7s9Z~z`CQ*6*S2(dp82<y
zZRjHV$TsD-8U9f>wsl#T#Lw+2{>ts@=Rf|&+^%mW@r#vTZ1|_&SlqQWiC?AsD#IUg
zV^!BLllb{&9l3N)oyyg9^`8L0`o_AheRmSgsN10F8%%oq#tmKbO!_WO-(}LL-MFjk
z=_WllL+#D*^~}C8H)E(tkER{L{ype6-dAvZyMB40t?LO}_E`mdkH=rnjMe@s>#W)F
zLAp;Uu>F15lZ{(69v7K%MwfzaG4tgu%SUPYSVNc2i7TC=v|MSW(ki7jN*5}vRa&RC
zN$F~(%}O^Y-K4ZdX{*xhN_Q!3QyS^!`)TQ%45hBpn9^LOc}nw@7AhU2v`A^O(osss
zDvc}Mrt{%8yOI4oefc)~r4~NdT3%`R4VC5HWL;O;P1Yq<ny*IbLZ#(~?v79CCiD90
zZZfZzcl#ylUCR6FSD4OSUaRs=iG0%Db=_qDS=UX^@w)qdXsOHBc8+xyeP>&;zR&0`
z^KLc0#(Ha(m!)0I`>I&QAd_$DoU*j*86Q(othm5_gXJ2Q%YJ+1@=aQPf&Dh8zqGu7
z@7en6#{ykn7j<9R;K%J5X`5KjMHM-ge?GW&LRI%`d--v(s{2%?OGejpzw3UY=H)fr
z{eC#Ba-rgdifg+2`?qnNF0`q8mC4`KeZ_y2e?#}*nEV^Mzx^NOZ|%O_<Ztb6AMl^p
z-_|{s^VM9@*1h0A%I{_lGx^=j|IGfp%yFE*VRS50`b{iz{WRXMRmL*cO(vRK5$&|%
zCO$9ZbD_U$d;Xj0hhqyUYV%X5%NLvThqsyf{pa*0vX9uZyqXSRKA(SO?paFIxw<OT
z?|*aWEzCTnoM`pDrcCMAb(zu+D>J44Rb_UnH|v{BS>IJ<%KE>6`m(+eC3!t$JoEV)
z<BykD8of*B%rWONyW@{_^7~cIOrgtXZtv{tU0S*@Q`VUU=Dg|s+Y223Tww!KU;nnU
zDXLe_cfOpy%jn%5-=%(Wm0zwjrnD^~_vN4ca?W<LZ}s>8ksh)S+m)Hmb}lY$Q$1~_
z{?>}B9)A71t*GhY*MCYyO%K`6?aKU&_3-(B4;e2Dd-(h2DHUfs2OGV+GG!mrruAvd
zl=G1`^;5*y<(KdKZzbo8ntWMy0o&1M#bW1drbn#Evi*AZSuxF=lbp1o!q68gml;3q
zm{6<rt5e#fdNYjPrKK&}eyffBi%W+&Uvs}1Q6lH<yW^XB_;17=KBlEdUvBRaCCxpK
zWx8VCrXC|%F0Fif583B6_mFmJ?jiMvWcls;>FsZ*9fbz(jt|Q6pV&KgjNl(u7G-IF
z%@Y0T5zy|Yyce9al@>F-ytFWDmBEEswYL#nSyGtws^Vpe-&Fi7#eZNrg5^Fjc$+hf
z{WhXxP}b8dmsR<W^H(GPj${ASmwU(Qtu#+*0n-Cm?tG>PGyNIUqnTDRJ&EbvN*6FK
zVEiOgJ`cz`c_yz5DhspDRyvB)4`&=Vv?xpF@uDo>Ukw%M5g%W0Te>+XE0|K0C4Nnh
z`1JLXqO4V{XIy1^#HSP3Z!*4LaD4jL+l#Vf92RDM$@+L*oz?kvqI1d$v$6~=%9431
z-JB2l`M=R}ed?F@W0jL}nr_a;wv`oSN&hd*x{djMy{e2{Ec1D8$5|s|nZH*0u2TO=
zyi>;HXa14()>P!{c*)OvkMW}wm=|K1QlD6+)H8@%A{Wb4|76Pifp}JB`q4RMRau<|
zNW7DJ=c|0a8AlBju>{SY>)Rd6lzMD2_sb?usWA8HE-#Il__UJcb69RfNi6dTuHP(<
zn^({A<3KF4Na_1bw{Uth^J^;eGsVxb1bygE|Gq#hQ~a2(dgVUAjtQ|$X@~qw-`}gb
zJn?@l^8wc9m;VCOyIH^ZKi|-E%JS9jSmsVHe|J1TGn>b|U!SEc@7wnWlP^E>Fisy)
zlAn1J)2%Ewi0NYX|D{T=Ve04qsnRk-W0?|HVwn=}VwoRv`)%iWWGa{ULS==XkB@Pd
zas0XL_A$<@hQ>1aaV_JodsuEQ+dZG@dZy1Z_3QHz(>E$lH0QFXuZU%CWc+82OHV!L
zpU1~C_i#C9jX66~!sBu9ivAIQTwTa=y=<aEV=Qy7ytQ8P`+onu_AfuK)K=DNJgLj-
zd?3+zW9qW5xXZ6!t&W@8tgei=v0N{uhbzrjIz;KkhI0M2pJ4u!{#R?pjb9&W*Px%E
zz0rQszOhUhcj#BOS<;?p*IFG<=#RNNZi};I{;bQI!1gp$R`XL3JTErXWnF7<v(~p+
z$MJ@&u3Ya+#%##C;AW0bGn+L&H0wCtkaej^-;h<r=T%=;Hfx-1*0?hzbBpOe8?r8E
zKHo3TI+EoVmu|?~ZV~-t%!y_mDf)R!mj7jfv13}Y{5Lw6jNX;y=ZjagWclOLo7Iwa
z2&YdN(`N9j%9gC-82@ZcBwNO9Tb8WvBH2PSvSl5C_23wO%EO``uNY(b_wlY?;b!~o
z%jbRBBU#UbWAd{7Hwu<Boy4@B=}e~2GrgPXYNq}d``3<%nS3YDa<e7Qx!KZ=dD%BI
zzjln9E$tc0J~75|@rqdXkxYF(2cAfD=d4)v^!Z%xxo)<^<5>1F%&)m3FZ<ZLiGDt-
zP~$?Oj{m&uEKZ*|D=$$_C&uF#pThJZmY05!m)(~!#}#8=5$l(6U#R0fFWVo-<!ra~
zuR<NqZnhuSXnB6N^o#s#Sy#B(8jp4S=Vg!K`aQ_?^ZnLPSrNI1{dw{o6_Mi~^~YI7
z<P4?%dW6rpswyInFyBwFW4dEPMdX(TPwo5@w)62>#n}gOKNwL`oGs`4qZE%)JSXDb
z<IlqjBER8$<5pBed^um=X2ug&ERKBpFwre57DPT_JcId<u-+XL7DTS)@@L;!5&0LV
zZ=G2Y>EZbF@yHQO2i~zba*CmIBDb>su6N9doX<Fm=}4s!Ucb&^eT)7;G;hV)h_vqu
zk?WcNz={_lzW*Lz{v^i7a{VimRx^Eg#nAMhEg-t;u8PRRCVi~-vnkpi;|9;2SFY(}
zvt>Oq*7T=%MWyzu8q+T2l~vj<ag~c_%X)Wgwv6|<=Bw3qtV_rXzfRk;R@-xGde4X0
z|991DKdse%SgZXjZuGo6uSxZ+&X#p$v)aEw?cb0s^XUdt{>qBgrroAg$a?<i6>sQ$
zvO`T=uUoMt@+|j{sa0Ddd#e5R*`#)FQa=b?!Ey)Q%k#?2Es<7k&#g13rgvp~7u+T1
zaBEg<Qa_~gbB7i`-;mDF9$NIPJ6lXW;uWn*TU4*m6)Rd53th3|P$zmH$CcTKI=z`5
zJiA5pwkq9a<oW)cp_k37GjXw&=Lgy6v>E^T&$F!I^4D>H*vNEK{kF(vrt!PdEk7>R
z-5K6LXY^csKhc?UGI~DB^s{(I&pJc5YkS9f$~a6<`<V5NFG)|6=OWV6zT|$%>&c$}
z_**)sPud>C@1y);O&_K7(6qns{&`FMP}Os&${nhDrWiRsFX$<8Y<Se+eb4MU<(hw4
z#D6|#eZ{hfe}7?oN&mDi5sOC6U#NVEGe4e-_=Y$Z#6926qPg&2%<Ovt|J7;vO-k#G
z9r22$p0cj5>nY=+NoieAe;;VAXznTdp!LodKPLM9iuI1U&%ELVy-)T+n!n%qh|~Re
zd%<n%9Y3yC&Rg%uxy5=XhyA!?#o9EF>$7LYdiBqG_0P1(vybumv1)DF!OY)OKP|GF
z@$UE=M*p`f-bg!=)1ysqr1|GGnN0n2n_f-pwfyyI1DL;K!uqtqhQ5<_@YO_po7#F#
z<T&5ynzo+PnPy(ItEcQ=Ta|8$`18_{P1_=ua=sIo`uOxF*Om6(7P*Sk7fz2EymGGa
z&uYp|@NZ!Lpr$;<`AKr;H5Df0Ca~O(ng%H@N|L*@sW>5b3(E~}8l`w_lH8R|@r2yZ
zSnlekDT>RJ<gRb3Ovv5Ia`C1r#WhKC6Pp$$<bKX_H#gNPu1k`e-qe(kdw}I;G_6+L
zoFq4^X+uKpQI?zAv`KMGlHAXmS`%`MSgxjNyW(9*atoT;5^~E}?vbX5C+(79DB9!6
zCRfw9MSjV0i<)AJbCcxioAMHJzh=3nrhLVPNpdeX4NA!Uj^$oyDpFjma-$TFRT|fH
z=^yKxrf53HCC<OGsa$bolHA)(RSCImEcbp>jpBtW*FSA1r+?H`tLgpIzGeJrQ=Q@_
zm5ZpKGL){?^u=a;eBRXR`Csro@tS6nzB}IP`RlJ!u4(oBU-TZx^fg`|?VQ`}NgQbP
zHZlI^+*Z#&r}>uY-xz<(e2EX+jNU6tK2PhB=I^(gJ%9bRbM7Wj#@APAy-oUdwX@B{
z^VYd-I!_c(jQRfk`T<6+kKR`<aAZF`Fa3yLaGd7(JlCvmGJ5&#K6jpLC_lH+OXlN@
zUShAS*j1d-OV{~E{+W3hy(Et1_L4Z3*GtZGV!fn3G0m6POV(jABllHPzLEQTePJ&-
z-zn@R^K!n*WoUj^sXV{A`~TzYPQaSD+K1uK5?S0Tl?ozCBG^_-s}uwRK@$@89Wv}{
zC|E^t*S1z_L%{{5b>CX5p;BAxz9543X~H6)pa{62h>4)Mwytfh+J5)B=kWZW?|I+%
z`j#tK=9l}-nKNr<CNt+uaz^9)JecD_l~YyJJc$zKyHA-(5(V0oRY)d*LqT%>K+da3
z+^1}}<Pn^2jVhZ*kL&a3@w^>>=imBbo`lqAoiuAVKLhf=2l=|-JS?YZp5zgDD`%cW
zJTIIlafaoXGHV`Pp7ZGWBMgtrcOE^@n<x2%=35Pt;kVQN$7#CTTCtp;Y1~4+1wL6a
zPeR<gVxHu8ntmFN1506gh-7++`4Efe8}lT#xSyXVaX=T-`CLrrYw^F+mq7n@MT;e?
zFrRjac)d`I>vw-)`Vg@`TRN_%-Luoh^x2E)`OIQTBQ2jVA;*=)k{49=J274k=cV$p
z#gf&#h;oixzfggsURiLNElYmiELwU<^7BSGzLpiy?QkRA&I*Qzzd!ckc9UCBirdZZ
z*(tcbpXHpS`BSi7h9{i&&VutF&*e2k#Pfg@T2G{gmUonvC!WVW%aQTh;ruLRmW<yA
z9$z8jjo>dUGOWbk1BH?Wu>PTbv!sA3uAf4QxPA&HYasnuP9bg&31x+nuW7y?F#V8(
z+^<V1llJuo`+udy`XBIn5tlR6Z=uuKNSAjTwUBN{g}vL6mH2z1P(qIX59Soo-yel^
zyC}rp4_k@~>3S)o+d-k^Figks6)+#L9&|8$Wcw$-4@@|nizUCo`r85P|1_+hJ97&q
z&5*u##csO2c+l$@-E=v3)BQm={a(lRUH2p0*IyIc*8mP(^KuBOFR_1ie+RN19W8Wr
z5Vs#^2l01NH~l`dSpNRPc3!-`=OO8U@n)B$)9b2k4&r&ESl{<RL2}=kpP>Hk8fOPQ
zPR-7<dI<U9_mh=)KDm$+&)*BJ#PdW2)~8|)yVG*q9mM?)%fEu*=9DeOdcVi=#PXlz
zH1HetFwFHe|9yVjd;PotuV3<T-n9$z4PLv@LHwP&(BVx5xt=H1J6u$ji_`Zkr--`u
z-_r9y2XX(p*FoGrZWQOIu#~!v>0<@Qp@T&Z;&tv4s{s&0eJZPAXpw`sUFXu_3+VU@
z==6NjSGyPL+pNuX5XYD6K=#YekJjLF_;p_+u7`zrjSlp85M3@EIQ}mSifMW=&9{)I
zcRPGJ0<L3abvuyX0VQjnIv60Hk`?)yczxoj!v+}dH)|v5b;sW8l}~Z_RghmCzBgUt
zNY>*IkS-p7G>)Xa#4InGu5l#S&!=Z;9Le&9>v@jiaYy5*kizeA$VaZHFDX-C{@7Vw
zj^c61%TYXDK6UsCrf1VyFGq1XcsYv8-OZ66XB@@l-+Mj9%~3oK_1<U8!EyuV<~Wk;
zrQ>I69LaLLx;D#^URQ7=>meskL-lf`*Q*@G?NCEwjiU;tcUhX3qj>#6;~2J|>=z@k
zycJ~&X?eZNZ=s{OofhGGV-Dxi{<$>0!ip^K4P^z6K~U~zSp_(qu>IoxaBEqE)w{5r
z>?mVdfAB|$$@RSbu)l53C&!0%eWD<}tZX;d!@6{MBM!g6@F=yEdfrNaeDFKLY6>c6
zrhzH5im`uAUa{l$ZgSmA{C#{B>Jfho{Yiaca$odBnViXm`1CB5<V&!&tljEs@bJg&
zR=cUkz@{=eFW$Fkw=zQ9nLoYX0{ER~wZ8X0h!}7DqK&SvJ64U5?}r0zbh$srdK3@l
zu<S)hZ!3FlbsxN5##+z02*<^;M^=nA+>f30$ZD7<)<bv*>7yVH*#5}M7kpl}j?sX(
z57-YCzb|e>$$I{EpZid8yKoySu9rtvsi(>BP&+PrEZoOACTGH7xIxDrStWrZj>)XE
z!3jG&tUm!grj53~bsX;79P_Z&W9(r~>Yw(edqMh2On+omM20&i|M&3QFnt><)<g8L
zHef847X`!pfU#JQPCNIJ)jo)mj;&+Kb)G3OJ@3Hp#TEP4v9DUl@ogPz+e#d5z2XeR
zOoidA{-eBE5ZBYV8C(Q$2gV-O-P8xPKbfB;(EoRu{x{Xi=6~k50QwL5kN7KyooMU=
zZh?68fArrD@%tEiSo=`}(J<?9u+ZRPorJMC|35;0a-Yy+T9|bj_O~BO_9M@7I_UPR
z#dv?Af}0Ng4;085a=rZEG3`+C{H6`_J%jV)4;C{_<*{@+eELvv|C&SNt^J-HgX;zx
zvxbWMpRA$c`N+bd;{Le+w-=}virdTX+3rKd{fqrjali9PzdmJ9A83PEPc(3DZ+%cN
zoQ{X9Hqz-Vr9!<$m|oMd8X6y^Hc}gSa{hGtST^3rz4gUjOwY;NJM<8I9~XjyVZXF{
zw#6zJ%6WXuVnwDGu0L6k=~=l#oUbECvT(Qq1-<oGd#9_dk2s%geZ=`}>my!wZKLyf
zpU$VDUl$w)nN8W&V*O0fMP-J5<UI6`jfQ^X%Aub3CPP0J`1+=K)+=FpVE=&agZ?;H
zg8Qpi$Gn^lj)LpHQ@xyagB!qOG(HKILR<^(nW}LT*RRHj?2i}C)HsnRlf0YZ<@7a_
z|G_31J)h{kf2eU<@F&doK82llezDkkJB<I%Tra0HP+nkamXmlsl10nSak>EMQ11-u
z6O;RZ;`n;+w-z~(>&4|$bDhNH(|iB5_x@q76WMPthkNfwY;+Qj6C0iA{@m#%jyD&_
zcL44qipPWA`-??R;{Bu|C-HugnD1FmZ~kIBeDQxxNAGz5dwjW0V)?mF;`U!m%P*$o
z@1^rC3f~W`7bqzg?N=Vgy2AeB=UHLwuyqV$|AU;_3(Jqxix%ra6k<KK2XhWF$1(k=
zlX%=4ZG92qMaM>4-v#0Kn)OSxjgGH_+D*NW%PqIyDP3MKX)GBgF26=6@%z|+7+Jo#
z1@<((hNe5ybT^uQlBOS}dJPk&>ku>0mQ26QdKhR|E~kpu&m7Ae=>6c`%=?%xXPCJD
z7gBSn1=OrzVm%HmHJvJF6fpd#a@a3}%ERl}1n{c^+F|1Uz-0X)rkku6Q1d}cPCD)H
zHB6k}tYP%JI88sqY=wMe`R8?#{rDl~dyKbnC&7*LAK`IrY<bZzar+d{KjD5aPA^g1
zJ~z_kw2md$6Z;-6qT|~*jBcmH#QmC_IR)iv%8Tjn+c1A;elg8o{O^2ZzZwnO4Y_VD
zl(+Y3hT$fc?`Ft!O@-+Zm!nwDvz+2#z5C;K=uhfLJ)`#TD_*y762*FWi?)jO@p8&d
z%-fK@sJs-*+h5qgr^57qT7Hy%ACEeT_x1PE{&L12^3R<0+*$xb*05Ml_vTj7XF045
zna_J$pVRYzL(Fu@2h)S&eX`^vUH&I=esl6{20m+GnAq($1FwUc?S_6|!hYxdO)~3`
zV7S8a<^iYX!*!fuTO0AbLaZOOvAl5@Io|wGF1A-W2r*e6`wKhha_OeZndLbC`!v2!
zm-ESCwB88a&Y#lt_mbv&N%Os=>*J9Xsh3ny?qR(R%JZ1!Vf`(2Cv_hxai-rZXK{KY
z&f8&sUQ;f?_*srPpAp;bX>9K-Zol@<;`U|lES@JhJB#N@ZqDLy&&^ppUvhR9x2KnM
zeMi!AG|uApMnlWfIE&}&a{B$0Gsj^1$ac{{y-2-B<@%BS&uP0dFPx6tf^?jY-Lto`
zgRsAr&Y!s4&z9%X@eQ?cgZ`JwhuZjn7BCjPS6)o#Ya>q2?!3`9WImE+kG5HoLC*I|
z>3H_i@yKj+Fx=uDh3v>4hIv#jvzY_&A21&Acg0CMzaG|0A>CuzL#*$p{k8+sSFLTM
z{qNIqyJ@*EY5bJNlHqhcQ5$>L1C5=j+wgq;^ueLl;`Y}_mvbYXo;GK3f6_*mw}KPD
z=W#a6VEX)a$np2{lO-l*BgEgXlVdx?#(c?eaeX@v7x%yJ!^Qn_e;RwySVCh3jqPcy
zp>gDJaX%1Ar#BM&!|{^#*A5rA7YWWkb2y!*r_*#fJ<dpIIfs~UVLD%x_owkAt4fIZ
z;~6%mz(PZY%?0$4RS&pthuoUV`~&f=oHn{#pnfK7SFarx*9V-R;dVpXf%fkYPdz(+
z2-{mZ9nZFrLOhb1`JJ433*xtrAF>Vx--E|YXMqbh9kR{`S8Qsd>*)|(A6axdJ*>Zh
z{vOk^a5?1Ud02mkv4{0;>OtC{?*E62-wzM#a@yZWZJ@SLuTs0I52(LW|3U5ly}Zcp
zjq%4z7@Gl5PkND@PN&?OZ-U<qn|3o^XW{%QXE#HBPfR>6r~5g%^+@Rd^Q_&BGYq#7
z^7)`SST3|LupS5fgO0zX+xJWQJ$z&p5BbuMFSa4=&SoC>u+D^-?4PpH(S68$mkni$
zZ5BYh2>P!Q)A9GylH=lee?E0J^j}Yh-$vbmw)fc$ZaD5t=TrQhw(WQroj(ujGMfKq
zYAv;i+KP(jH*h`EhO|2+)7we=cT;~wx8d)tQt1DbroW`}1I794OC3aYqPkMuspF{=
zs3Fu?Y6|rOYBqHtbqO_(T1Z`s%9)LzCC9^hA5A|(JxQ&lo~2%*n$ZHfJWKF6`qS~<
zHg_N$&QFJn+i5P{o^$E;`pD`b^#6K?c$^}?zpP#(-#a&nnBNWS?LAy29tQ*GcF^Nk
z2R)9J;`mmrEv4m`((+5`{-|`gc>QPZaPhc*h;fDT$$60{dJ>0+dfR<>!EtTy+BQ1<
zjl;$Lb0aOUakzL~6YJ5;oYg&?+`nm^=KSyamE!)ld$@QW`QP=9o(?D1!=RlW-QV?|
zx4)$0uds=L>6tmJ|A-hk?&su5Mu_8=j3DKbn54t+P;7sA=(rng@2lX*`Ax;~y$<4h
z7CH2u*NMN&_BznxCf9hATt9cF<v7#wokxiC)y|~D_-l@vaJ@a4Q-SSS&m6Dd$bE-%
z#~W-ug8n(H8*IKn#p@`Sj+>YbINf6Vu*Y-6>ndHxMeiRMue&_UdCvUUL9R!ir{`DC
zneSk@r^n@3FZ%K!IqamNKF|R<yC2JIx2Xk-m$ch7f;WGBZZ&)^8U83epK%@`o>#by
z5YH>zM~LSW?jywWi=*^>%x#2tylBUEu`iCd({_SK@jU7IQ3V}dLx*q2-<?yoYiKzN
zI=q%Hw{&V4p6BuvVJvyR#;q^J^XLNw7MoU>-jFqN<~rE7VqG87ZgP3nx;|w8FsQ;}
za~sl~Dt24H0$m{H2Ep+HVzR$`7h*ezJu8YF#PeSjI}~Eyigoxqid=^v&&^O)92`W>
z%cm@5ZQq3c|15cK<K9lL%d@u2;d)bO#YsAyCvp4PKl|he@i@-fsvv({1)N90^{MoV
zZ7jJ@0QI{u&V+Q*UV2uA*lu|1(l9Ow^6M*Pww+Ku{4TP6Nj*a)+vRfTuY-JWpTu@H
zm^W8u`#Ft^sNd6c6OG%cw`uxc7&qA1*pc<_f$eU{^}078o;j-lp032g^9MR`zMx+9
z2=RVF2d+1`zKHq1tWepKb`e`EJlMBjxa}2TwtqtX-qH#aecp%|`}`ob+gZ6H&UP%0
zFV0p0?yZQU<BhY8hWNo8vHzm2DVV-;MT%_-O(*#e)BHP%;%u`ao;fSdb{;j4>R=$>
z+c?`Ih$|{=nW6AKc$Slm<(Vo(>!~d;y<+}s+bxiP(yV#5--FjG7Tf-Q73v{Z%(FcR
z@g494__(5*evjv2c`qRr_ZRbQYoWiSa-MB7*spS(t@t~Coh|v^%v-q5mgKXmlyjZX
zUsbk_w!>RzOZFFzmD_B^=P`8C?dXoxUC8HBdB=*hgC12W){7ZaX`%PmM4!*OPxFf&
zD7cT`Q|9nX{GLJme)@g7Pq)iF$xA3V1?smAe4S;yDtFWA%ae%XH(@)Rc?&Jro_Xbp
z`y<5fMSmCa&r%yx`@1{=_vre&kp1iXKf1Y)?QzvwHy3d~=;k8sN8Mb+{iB-;y$|g|
zk1sCbenf-j7DT#;=dD^SXMdrIt|!s@3fPapbUr>NUMKgf6rT@M`=j`rom*ctV1C%o
z*?L1hWo0{!<(vxQph^`R1qRL?$|i$3tJ`fBfZ>%ETk&~8k1+qUoIB{2A{N`@?Js<8
zn+y5kDxcea1tx<J;P?IAAJge{XVK|?WIO#jskijVb^-Wc&Li8UG+s^Ptu+1~<L9<p
zp*$UwCx<w2?sMB8A)YkrIh_vCX_a!GEWgY7a-J+dqPRUleF2D5W>wJVl$5&s^*&iI
zr7pIf|9{%~oOBV}Ih}MF`u}VAB1UY_RfFsASx$}1YB=sy?S6{w&1TGP!}Jq#yIrP2
z`Dtn0E(@Ul$=y$B{--Xa9jH9#smq`j3}Z9Pi$1?8gC)n$S(Os0cpUCewd;Efme>5s
z8lF7q`q*@Pnr<(B&x^FTwU?5Aq{#=}puA&wz0Yy7m%a}%w9BN=ZEEDj{EfVrznG5K
zSt@S7&QkGv?M%yelZwv)>Aeo=Mbk~z<T&$jr57E}ODZ1Uy`<uOCp%7jUdJKkBusZ+
zr9vv6uPCJA`GT!2`5vu+ba6fvI9_N+hu5jJb2XU0zfeofrDjnhQD~np6|XO+(>PuF
z9_(-6J~qa1-;-MKZ^`#C@lX++?v2!9+J7UR|6)2l1yb=jA4N2Mqg4DJAC-#d11F{8
z`9LwIGly$1efR8>Qt|wtMk<~c9HlDykn1nH*(^R^=c`ILt2-~rb#gZ=aeHc$PV<3!
z6{&5~pYFkR=sj&x@wp6b(v^_DGP_NB4AM*XbkphWmXd$s2+Qe~-h}lG?WX8+CEBDN
zknhMISzqzF2yN0ot)N{33~zfMo`bZw5r^Mj$a19K$c9Sk8`~h=yyp<p1nX;CCCgdB
z5|BK{WPhbZCax!m>?Wk|pDmI72L4iMPoHzpUncI)UgCZ_C(j-8a|gU+<ca^gvh8K!
z^8gew@%aI6GO`>VuF}fHcKUK|Bpg3?9?ZgcW9n`^kDODm5aY`10-C;&S}GIUx9^pS
z?blDr#CGZ@Wnw$^Hkr7c_io=>+D^SgCblPkDHGd^-<OH)Kl_gq+k-ogr0u<Xue)R1
zo^3~;A7RsH<_x$_m+LlCoc=8A-<7Sw_=ob17(dL;!MLHa5#xWdi!pAi>=-GwukId6
zrf=wsrz6Go(e|#yw`NFONxA!HD=>z3&lu<A<zVbLBNAgvWhurXGjcJ$SGlnt8E*IN
z8dtF$^HEHHxT+gtXupi{59R&cNdLt%?ql3gsla&U40|^+d|PF^&C+bRUjmZ)VBwV&
zocJ8Qy|mti#*J(TbLNTXi|mP9H}VAQ?K5)S$UjHyno)%PJND+fk?+a<y&Ey!U%0Lh
zIqw`)QA*=t?En1eUN`Z3bkvQWPrHfVr@e0C_om2>JPCVQT9Ms#>OE>5xG}Yu);lhy
z^}35`z3XCH-@2IA$1kP%N@+ejT7TD$)=#yg^;7L={oNXzPS~%zk^SL*s9)q&LXLBb
zB}%Xg>ZinlbznA4{{(D;I3K(KuA%8flD?P5<>1N{izO{IzK-6J{0ZMD3)F9h$KImD
zM6KQiZ{>8*>FID2+Z%VdiRT?1ZsPWP-%YIlao<g>|DnKo3I3@k@p)m#@}A=Gfped_
zk^5EivlMv0AD(wa+p8!XxBm|3eXDaE#pRvjI7UJ4OL<|w=SOoKlOYbDDH$cMuN=pT
z5G!ZqI7WeEX1=8B?<HM-ZuGu<jw4x5V_-OOedaj2{6Wr3a~zjECKfyXfcFXek0MWo
zhv!g?`T{J^f_NxAUn{Hk_iO)AMI?P{|52$h{DV2UPGY;WTqp5<VE<8BSZ=NpX+ID+
zH`hr#&g43g<I;h=TzdcIf9^wx$D>?&oxb-zTCS6L{OY}r<vfaP@B5+NkOJ1jfD`Vc
z$abAu;DyU!_iX#2;&Ia+@6+bwDMpF+0Tp(%z2Ybt+!qW??QOT{A&JKI+1qZ=&53;P
zekfPqc%tAwoH)Jin7)7ZP#bbT)Bc2(jyIByS4@|k2*dNX#{66t@%xkOB7T4Jn8ITG
zJ<vA|#+Nkvj;;7Ter}r$aa?5%o~IsJn~UcoIeF>yJV3l(^zMl)I^W{`A?@5qsT7vu
z!aO+6qAxK&JpYm&7Z#2p^*^AUjf^}=|3J1o?&srj+-1+<xRf%hcYnW7EO)lM%<(0e
zJ}-J)D5Cq3qJQs4#OW_`D}nN+<@9c+MQ%SrJSQiYE{Am7u5<E=a6jUAp!a&nLfpUP
z7L3N@EYuHj6SwQ9ZjWL3*)yNIT?MzMK6SeZZUn{s$y2v=I9*TO#O+hOFQ%PaL9bV&
z;PUo5k%3N{m5n}_GmpBMnui9?EkvK?%%jgCSV#MBqn1#2Qx8!qs3vLy^*lOhRs;Q=
z-cHjksQ-yO=(C(h=*kuA=y;#gd@Me{BJhMQy<cjJ@z1mD&}TVAsWR$lss~k0wd0q<
zc9b&9j$ehk+llRO-R;Eox9)ag`&)NAvHh*Po!I`?-A-(O>ux8uzje10+uyp|iS2LQ
z?Zo!C?sj7PTX)(n*qyc)cDEDT1^<5?Upp_hFK*|>cE|0!SdKGoul(Qb!rFP#E)?38
z(sp{i?ZA55dnstUt=@KC|Lc78&fouievZ<1en)A$K4(X<zL7K5AA)wEw4PRPy|v!@
zY`xRz+}rMuwi|Y)?Gokq9JrSJ9Qu1R$3;Ak&v6m=XF2ruX^x9{oi4{kJYUbj->E0p
zF2wx%XD@US_lpZ%#Os&~>F@>g_h0Y#@PDR9JU;eLNAL6%(cg(SjFk0!dmvN8`a;*2
z4}h+MkA$w0&wks6St$7kx}QjvKsQ&Shc44+8FZC>RzaTPK5L+B=(8SDUiP_4`dXRE
zXRDj!v-Mr*O00i_JdV~+q3dk@4|Jv0exnC6Zq{+oecM_GU3cp_&>d&}33Pp}E1;{e
zHbNKbSdAITgj(A`H_|$7j15z7JrlZ()^nlTY`qA&ZPuSc_p<fp(Cx4;fUd!&5W4oZ
zU%^oBwi}>3&Q|@d4YRlJfN?g=!M?9U_h?@S=pOIu4BeA`WzaSDeG|Ha`n?0)*nZ=n
zo7LYBx@-GSgs$5_&A5S#WKbA<E*d<Sqz_&M-Hn4kg>K{E&!O8qxB$9sgA1X1dGJ@z
z?HIfPy5_-Kq1!$9Tj(<O-$7Sm{{wVw?Ds;qzx^TT4zfQ6U3>cz&~>yoLO0jG7P@--
z)6gxjKL_2F_HEEDvTuj(TKi7uZnW=$?pFKT&@Hxq09}LqW9XLJ{{h_}?O#H-+ky44
zVQxEELHE8xKj=Pm7zEv?4sUpHOxVb*F|RXGBR_=h1<&#0-eaKlxYo&o_(Hq<eIhTc
zLHh}t(80nrbeM1(eWLvfbrmLik^Jun(@;-gIqEO0M%BU=G(y;kCJ4LHG@%vE6mFq2
z1*`F-oCU)B=n^4tJRIbid?9pv1{yU!6I?CCkI%!nWPAy_YrGNMAnX}$!uaTTGsYF;
zEf`mghl^IwzivEKI)w6?$E(l_<JFjcWqbz4UE}rW?eTf&gYgD%weWa+3C5$mjo=1h
zjJFx}^d8NT<)lD22!Y-zi1URA?+i57I~&{}2;PP0Wbd7rJ`Mdw$U%1s^Sn)%e%RZB
zmV2{2Dd(hj9%}M7pr^b`&@<jfwAtH)Uhp=fSG+Cgb#F#OhVS-f(L3H!^jB{g`ovp_
z{^_klUwP|M&c}dS`xw#wKC(Wf96KKsI>aXf9p;mVN_`mk^_nk?@{yure01nopA6K?
zCmY-#$bIw}2l|-M5FZN~=>vbD1H;GpuxO%>6x<-B`6$sWA00Z&M~{BwV*>Mq&wW_<
zO63a$J~Fh>XEeA$_{v9x@fM#FwAjalmiU;_T|O3ck54zaM>yyMe*p#Ml=<YLl|Cit
zFFvK<9-+p^gmHt91wHG-_9gjSePrlmpAz(%58IEV-|$hPJw6%eeV;t^kq_IS^#9#Q
zhQ9Ez9YCg+@g0rY`l`Tu;dS2()WJ6ob@nYmWxgi#P2c>1B;PyeH^Mk{r!d~vfaxFk
zmY_>~ji}z&gf8=CUn9e<@|B@$e9h=aU*jN>zRlN+ZYO_41o2K^7X8szhVJv-33>{L
zeXG%O-x_d_aMHI6Z1pzz?tGo}KkaJ)^M!N1>|kP>uMBPXRiT}}YS2^Y^3{NQgxkIu
znEt>w6Vo62=3)GYuK|7OTY|E3BWfi#q5b4$bdcPFz9H`dJq0H@V^7BGB4<%IxfC5O
zm!a>;T|rO5Q?A6=SFS<><ZAGU5Gc>UI8vU6#>q?2M7aq~lUq=ooPC3gXR2I=&XB9n
zIr0p2p*#;=EH6Qq%1vm#yc+ZrR?00He<|+*TfNuI*&(F7Z{(xF6M{jm23x&%%QG?k
zusk0vmzSU?<vUT6+=QNzSEFa-7PML3g<g=e4y4>Gavr@dm!jQrC3;7$LVuO3!6U*G
zxenu3@(h&o%LH4!t^M>E5Aw@H-|)-FbSFOp#$J9UsN8QSrcdxQVw~(}Mko2f-wMHW
zeBdWTr}?>pt=>6)DvX!=WuUA5@-cm_-%j)=ziRY|p9T9j`E`MwLW>{#@fDPJ$xnuM
z_$g6~p9;O@mx12%%R?Xfm7vf3WN_6hU--*Uh5qA5YHQ{T5`R5v>z@xE5eE8`t7G|s
zqrU|m?hk*m1@TCK7JbW~2agEu{!)y+{bi`XzbmFI{Z$x;`>R1uA;v!gW37K4n&MxA
zPWCsUnf?}Zx_=jVM408zI+O8z>@P!e{Z(k5e+IhTKM!5)pAS|GYtb`8C3-}7<!`|L
z)`}9ezru*xDNN`Pg#{g^V26|ONEI@4ltP7$QDmTF6?v$aA|E^=$Q30Rs})8xRAEA+
z6c#jI0e>n6<s~U(Xu3j$W+*by4;6ZJrXmlWt01j8@`Xi;67*Ar5&c|YLJJgTv`}F|
zzfv$RB>x5l{3#i@Rl$Rv!nX=3#@{Jq=no1Nx>u2b9#Z6?#}p;#355}C6^sfK#<dDF
zdRoCqNxA0~QnXE>MB5cQv{Ru+yA*loZAA(CKw&~3D=g?A3RXtSd8yz*Pk{}PVQdwU
zhxQ97K?enx&^H1ss8awtl6?PN0%Yjh0V>oZAOrOa$V1fuC1_-T2^9h?=;VMd&{LQe
zz`Bxhass3vEZ+bb#-9c#G0qQAVZ1Uxhw-|A42(Ai=rP_AU_eU)jOgwF){T_2KR|^Z
z3CKW?2jrnY2kZoo2vq?lj2i>^QDi#K2e_ga161Hu;c9>yV{<?zdNZIJy&GTw^M&66
z*f)t!19;F=cpf0b`0oG}%1_8ZZ6@TQ116N9uTL<c4ihY>^Mo$2OOQ=~Kcj>4-kiXq
z?@Zu9Phs2yS9JV@%(qGGH-Q;V@=csj4Q>!LsHYG$K|O}dSNsG6m@lMH*a><H854{c
ze>lO6&YaK%wtCN<z`sM>GQk!7*90|sc|s=octSopbmC4_Ik6g@Hn9uMo5;J9;lG*a
zik3}Oqa71<V7|aBGcmSN>M<Ux+=;Q5vKoz6cA<-u{JW%_HA+`>w^9ur5vrA4V71Vs
z<liIlJ*66brpyGZg@2U!pr_!kGJ^SnQe{SiR4mjg$QQy@8RLjCsuEPIvY;s{_(MKO
zpRCG2GgYehNjzPpLuaY<=zNvhla&9lYA47GxoE5R7b>MU$zQC}p(QG{56QPnl?Ubv
zdsHRpLDf#MS}0Q)eMx$=%8Xu6N#!KIqEe#QRn_1Tp<89f_*YdI#!pm?AIbMh<qB2{
zT%aD~A%U*`Bpw!+kB$r6iG~EK6(n67n2D|o>_T@0W(1IO4h80+#{x^x6M-hw7-&Ij
z1K9~A-|0YCuv$15m=7Ki+5>lja2^zBo(StnxE-iel6(&Wb?D<jJ^DvrK3FZh3^ZWe
zSFKc${I97qK~KS6of$}$<4|=T2<JWO64Xs?){uC#nhzo4drz$g^95hE0S!<a(Li-I
z_772;F^*F+p(J0TnnlypGE}G5p;Og*bcWi1&QTlDg=#apSj~iy;g_nVXuevBu2k#L
zFV&gg5n;Vrk8!cufR?CB&|PXHx<_q752`I_nHv6V5z4Jp^WYKT7qtxI2DJ)3tJa~d
zYCU>cZ9uQ7jpz-v3GGpv(feu(`bf=0kaB-lv*-)86lF9rw2wxK_SNXn*EAWZy+)4?
z)#RZgGzQdFQ-Z#&F{1BkOz8U>GwP$Upb8BWNye+vz#mA0!5SGFp;4i+8XYQV^k}Lk
zA3P#V(HJn!)|8;LH9OG-8YB9NrW*ZB(}jMaVWLR+D>OV>q*0>lG&*#%CLjGqvlBIF
zy3p@6s%SFYPnrz$fF>V3sxhJ!8Z-JYjRmdNz#m{j{(23IHfeaY1#TCU^h+8U+M!XQ
z7EK0vOOuD*)0ChOH74|##)AH(=|ca}@Uf&ENsudQ8>B)92C31(K^drHP$oJ&C=VSO
zWI*2vDnZ?YjHpMD3H1)Lp#DK@94TKJl#d1l?L@<aOlV9{HL49VqbWfabTa&b8yPM$
z2>$dFoE{`YX9eld`9XU0;~)!~8^k7%e0f1Ux;#jRt`2fV*9NK3O+jk(>!1vDM^GkO
z8kC3b4l<zogG$gNK}Pg=kQx0sh|!YqR0T=Vx*#Rm7-T@t2N^+6;bM>(y&A*_BsK@}
zV7_oONQ&{@AXkik3(7>F234cagZM;}@9!X2ln+*;Ho=+bfZ%-e^<V?)5WEw04mP5)
z;A-^EU^Dtoumv3#+=Y%0=95VIe!)_7Vz4W!309(E!D=)*SO>NW3Bj2dCkN{>o)m0G
zKM3x^^l8CNGRc<{%!B#DykIHD9|gN&yd+qK>VwtjvfvDKRd6P{CO9A67`zkR7HkAP
zh3&!B81D@3LVpbAQ%L#yf?d(W!Ai6|SdE?x&O}YYdh}FqK6)m2C)ylbja~@uLazk#
zsieH?!LDd`uo}G+oQeJ#TnMffo&>w5k$mSul%S{37NW+uJw%6bXGjLdT_Kt1?GQbt
zKM2Xg_;H8<<3B=5Fn$?g#Fz~=VQdv@#<*Xo1>-@XOgb6Q8=*XyFF1utF?I=6qHdu&
zbabd5eJ|92dWITN-%v9e5DI^M3*`ic@?gFY5-P<wGE|0fT&OFW7^+0mLe;1)REJIt
z%|vH}>d`r&26SPl5nUWw1MU%)hMF<X4`n8k@vRJ%qF;u(f?dM;P$kA&LfI)~I*LP;
zXi2CV-4&`s_k?Dm2SfE}S!h058M+hwCA1WT>qeo~7&nA=p=U#R9VxdpR0?_umqT4K
zz80zkTZJ2;DvWzV)#&}uO!QG`KKgs;PV_~n5oN-v(LQ0W8Km64VQTcXFdYcz1!0*O
z4-L~}JR&R~tQK6u3>YiIjHoKC8ieCdm>J`Uur7>a!<Y|9IYJl@<_oD|QjDjBxni6Z
zro=cqObs3pW{2r8{v<3D`+pXu$M}n|e2iCw889viGotIlsxf_Ym>J`5!n!bqvw=)9
z-tWU$5RN}#JbEBZis?tgTrsW)Q)2wDFg3>2VLFWK!!j{$3e#iU5|)qgr7#1=9br2$
zwuBimz7<xD@x3rJ#t*}~Fn$)sWRdCkD@+3J5&j92Vk`+)qPF2`FkcuLuETh6cm~Ff
z;hE_0a6P7v49^FT2ycZOF!l&HqTb=vnC>5L#yBXPnM%eN9?pYsejP5wSR3w&aZ0!v
zogAKtW`^gZ)58tutni)a{BR@sad<VF8*WDP!n@Gr;mn7m{MF$+x;9*jZVGorzYbTT
zJHpjyX}At-6?TW~(f#51n0_SOfbsG0of!WdZp64MybI&HaAq1At}&bk^M&)_8R*6E
zJoIX~5&N6Nt1-SA&P*ry?uPT|Z{bp~Rd^b%#`t--4&%SWGce{OGEtidBe+2r5Mf4#
zL@+Z*IW7@W)Gb1Zj*ifw??vcQ&j<tR8(~BPBFt!D1T&Ki9}*!&BO{b(T!aoyjL@TL
z5e8HjVMM1!n9&&#7IaPolS9f`7$HR$M<~&y5jr$KLXWPDC;<Jod>LWDczuKs-4bC&
zizAp>q@0onDY`2{iSCKep$8-MXjy~-t&A|DzeJePnh0h#8NMMxik^*7qOB1+^m2qA
zy%te|-iR=wJrO4KeuNo)6v50P<@_EYMPEcHQ6^G{_K7S(`$oc_lS97OB4wz3WF9&+
zvIHFwnK6&_ca6+L-;Ok(??#rO??)O@pGXs`h_s-pNOnFME;zCTjfi9xkT^C{iVBfR
zG&NF(PKnf`S&`C(<a?DJsYGW->d*y|di0Y>1NvE{5&a_4jIM}e7LoFcBBkiMNF};C
zQipyMnSmN2_2~DJ2K1*$!$)Me1Cd7bXe9G7)JhX7B6aA$BK2r>qyepuG@?zB7BF9E
ziR=dV2$v$+Pe|MmDFyEdmPi@Kw<47o-;30t4<q&Hvq&@gS0uBT<o_p9ib|rCsBM%1
z9T;Uq2S=Gv$0+!-c*s9IN{5b&(xY!h8Bq5qBkB<)T|)ACM=4SNC>^Sd%KDs4Z%~vT
zgzE!Q1~ev0nMY!6lnzaa%0MSa<)N8T26TFq5uFufM(0N{Uy$KGj?#mkLT;398Hw|v
z^yu=a67YnuI?9A@jIyBLMzPCD`mU%v5SD*b33@cjgjPhUR*>|6MVZj*D0U@@>!W07
zQ<MsAiON7PMac?D|BfgXYKh7~Z$;&y_o7UzNdJdX>}uk(C<(Yn_$x|<@jp>{s3e*#
zBK>WnW$3_Y6*@RN19gnfLx)Ezza;raM(fbGqS>!V>>e#cJ)$#E@8~?#Ke_}}M(fs)
zd_mEAG(1|imc%j9DpVUSTSwxQXcam+Is?s&&O@h18_`+OCUkzZ8T~lgg62lE>&ftW
z(K2*-v<h7vE!{xU*G9|GP0>p9>uBXhlD;Eahn7a`(cRGobboXyxJNh=ZN&I^v>E+5
zn%P8#tBRJQb<s++G1{_)q@Ryww-PT#=b=}l4Iunpi7vtTW^~Edr2pM$6Z%`U=_HAt
zMqAM5(d^G8{ySQKh78BY7*LxSBRU|)jJ_VDyhQRj#7M7_e9kd?Gl^v}1`F}c82t_6
zJ26Z*aa@eChd4e)dWYoqi(wv-cw&qc)x_u@lk~6{0~#G;L=$4nXmSkmg!G>jBSk-m
zQKHjgbZAbD9-S9sKtGBxqDx}Ts6K{yN`_w+BSlxmDA6@BI&@=<9^DpWMz_Z>&q)5A
zF;eu$7$v$dMi1T-4#ybK@)#qgpNui1rWodTGTf;cDS9Tx46Q`r`dbV$fOsKBie8CP
zqSs?|Xm^Yry%S>qJ%wLmjOddXGx}!?1Fio&g;z0Bl#5lO*0DOYf2?u@>2DXSLx;rb
z(P6O$R2pkUN5z`aF|kS+nVzw+I@Bvx=}U%}$Li1tv3gV;Yd}L|jc8P?-j56yA8SC9
zVx>y>_d+2Zh3mbs28i>84`Yq!%vimO#B*Z}=%QFAki?(HO3}|_^=Lt?0WFMW)TIAc
zu~KwHtO4B`Yec_|?bfjHz4$Ix8AS5^5UWG?#_G{Su?F;5tTdSPKM|`$jj?*PHr9Zi
zjy0m^V$En<tUiR~Z;v&gow3qT5_iQa(c7{5FcLqAHK31Ujp!e-X7pt&6HfZGaZ=PO
zPKox5)1ianm<ZDUjW{Xl6sM0Tu}ho*b&F#XNIW`DioO@8L_OnlsBfGe4Tv+KfpJDO
zB+iUR#xYtld|aFqO^j2bX>mGK7pF(3#u?BVaYl4boEcph#|UKj#c@(}X`C{V#QAYL
zbY+|#{W8vgu8%XKTjI=UaU7FG@|VO((Oq#$bWfZPJs77)%i;`ZWt<WHCC-f2#3@tB
z@C|V~^lY3SZH+Uam*b4+wKy|+BaTTU`FrA&lZf}@bm*fvJ^Fi`0eul?MwxhKGRfB`
zUW)dOSE8@Q>rnf6JvubrfR2baqOS2~^zC?N3K{<0_--B9{@#z*XOQoUPrLzD#2Zmn
zyz~Q-9vrVjBjTA%GF)uDWEvSxh}UJ4I5l36PKlS!V3`*}R=j>LNzaZqptIxQ?-e0l
z5U*Q8%KIeVfPNNlM8Ak<a!LA%cqv*GuSD0y>(I^dW)SX^$1|T14e?6!`*<DtQ@kEM
z5N|+_#_Ly*d=>GMRb)E<6|XNMado`mD`I`T5p9Y$qb>2e^(6gLylykGBVLbM;`Lj|
zblr+Kp!eb>+emp2<Fn9b@ycS7|F3uh`cJ$Ol_W^_k#ySxB|0!cdWgh>6O^c9g5fxc
zhbI`(kqOG5$$sap1RdxpxF_gQj|4NAFL);~|04P)NKs{i^cNBbB`DGG1cQmhF$qRg
zn;@wn)0vWB1mXTng07aBna~aH5vC_-P7!A%=;}%O`~*Gvae@KOO)#Q)31)P80@Fb9
ztxk}lYZH{{rUX6ub%Fuikzhni6U^xD1l<`j-2Q~_vt)cn5(>@{k0%(K$$b8tU_`4D
znDZpAOVG8F{EZ227fHVJ3Fb>=d%BpwTqfyP6Qrm)L5bc>(4lt|^yqI12J~ryvV$zo
z=Ls5ckMMVb+chGut+5bowB{S6+yPpB7x8ti5p~d-QD-gFP10prDf*^XiN2%NqvNy&
zbiCFGJ`w!1W{f9lnVV!djkfeQ8BdtD8;#a#?vOY^TZ$%Y-R_ZilC}W-KwER4#M89K
zN2I(Qtr>hF%+oTDN&Jyk3ce7QXbmrjdabT62kFbSdUTc6fUeOR!50Gjr)odqHmwqT
zB5c<h`*X1Tc52P&k6LB`iT7!x=wWTC9S7qt*GgU|p44WcCT%x*N}Dy9q@U4B?1|0V
z8uWrz@&<{oXtU7k+HSO4n+1P2vPZb1l{gT8)oRcu+5+@Xt;CU}ztU!*oKS;W3!0%M
zy}wX^+6mq05FyKnqz@A$!-!I$039WCqho|DXOccvkPIh!2{ou(=td_9ZX-y#S|~t6
z1&IrZql7FpUMNMA1c{WSrwavWhTtY6@rQyDd?L&g%;;Q!8A+D!B0&m15k3_dR}z0N
zD8VN}fgpX0gY&9FL63eV7|;!Z5#1`7(QgIi+a%w2f)4#b(4%_=B~&nk`;3APJtj!U
zkobh4M2&(0trd*uX+ifc>3>epqiuq5EQ#9%GukOgJxJUoDAC)34t*f#(Z_-T{X;OK
zF9kEoCNl4n;j9w%p2U8M26RxO5q%@kj5;NDgL?#*M8=Ecb4!$>qZ5_rdx;uwkKmc8
z!`L^m6ytzIxA7!BFtHmANz{0gI5N=y!tp<`6ywB1BgScoZa$>HF0mV(nyB$5@r*<r
zm@mvp)T0X%OEG<MqMMxbUz%tD;rO3uL{}zuWBQkg8b8v1ePSuPCDF~F#Knn95RU(e
zI&@cJH>U4N)F?>*gNdbRS)vhy`;&=g^p`}p0MfrEk(of!8xp1H*+eDUny5oBC+g8_
ziJFNd|Bb{_v?o!bB=P;k0`yU$Mn&S^6HCz-iA*3Vmr0U<dxSnoQjGg1Dbd%Gbf|q&
z0rnr7Bvq6ABa)P;Ymx@sBfOoY!}#4KJ^Fr<0rg2L#r}#UBgU#EiH774PAWhnk~Bdi
zj!h~>g(OKZiBppb&?!mE5Hh~3Bn`Mn$WGE>JUdB`E=V$<pCpxH|Id;np(NiINd@SN
zBx4vEz9`9zu1iuzka%;F8T}@Si6pThNs4}-q(py8GN1>NjOfuMw<uC>MUozb-~UMk
z7*{75Fs@JP#<(d-8BO}PB<avgNm<|?p(9C;u_eiX-b!+dA?f#$3ebm1-RQHVtXPu%
zSCU&C@t>puRFZ4};rO3yL<c5!WBTCatay^oG1)DFI6S!k9huyXzLlJ%CF$<TZUWIG
zxd8P}?neESvl2<VGMPyt<p(88(ePwu5{YAyrKmQUnM~r8WGOm1S+65;X0idDo@_*C
zC7aRt$@;0J|HsJ&G&k9Z<|UgyB>Si3$;>q3>SQIlHd%*mN;c0Y>0c)^3y3?Cm1t?Q
z4&9w>K=&sb(Id%*MI_(xWFz`>GV>9MtCFQ?U9w>@i5ruR==o&kQxacHmZDdab*MR6
zkKRnyEg}8yChO7Pl8xxoWHb6aS(;1w|DCKv`4l~BlVU&zq?pmyQ<%?4K8F+~>YSoO
zWhn;q%@ia0P71S><QtbFMaQS;P`?yCIx)qJYEqcbNxrZYB^sTgLlaUAXmW}Xos`1p
zNxlzKr0BF19h#G(N9Uy&(T`Hh=#ms^9?7pyQKHLI^ysP-1G*-~jBZR}z99Lwr6|$u
zDLQm#iUIvG#fa`pVe(17!zog<JjGBz;*%*x)Re+3Bk`#eDS9SFhc>6^(F-ZYBC_3F
zNin0>Q<yJF+?^st@1!WvUsH7GlN94RQr@2_X7p8xbUlf=R3&Pi+Rr344Vv+;$<yR(
ziZ>;h(oFfO(@hIaOH9ks^ro$*9i}~|Bc{!hkDH28e>PQ{>P_vYA5+a)%hEndwV14`
z`c=Km99;E&&i3>lQxj)cRSm0Jn!R~)l4(@cJ5}SVysP}HR8_%MkyUY3Nmc1p+tatF
zXH;EIolzxr=Tx<&UQYeE>a(gZs#am&HC5ZHzN`ANY9GYMs!mkRz_$tVkzA*$veKHX
zE>>Nw`Y84A^cz)VDsET(TJ@wVC^aaRsdlKARxeB2JpIk;&6D4$eiJ@VfNqj01U^Mn
zZ%mD?-la=~_lMPUsuxz1ZeI1})D_ihp}PsX<W2H?Q@smbdts<$X(y^{svF>a4)R>C
zzE*v?x~qEMv|p?LtY&MhYx>vJPp_XovgR##x!3$ztpc~EhS%(yMog&*O3eVtduq*s
znr)LdPyVE4X$^_<Yc@<>U9+iXdrfK0?wSKNM{Aa)ZBMVLIaZZqGSwuRPStFlym>PD
z)C7HI&)k}NsYXbDRm0Viu66CJn*Q*%gZB`4_jX-s--hVj+PK=pS{;0vT05h54t)Bg
zHV>lZwMDh-YD3eCYZqsifct9qr5~v^!E0Z7UG1o}-gi^&_Vi_G<yo!ZrP^z?Wcl5w
z4NQGl`@Ht=+RALnsW(oopZQVh@Kd2_p=oZ=^*iNvDloM>T}+vHDg@FZPknJ}-KmmO
z+a{5`(>^45cbz%}eWrbQ?9|Cqrc-B5k+s!)ip+D8sR!aD)1y;=oFdEZ<*Ch+x2AG+
zj+1Qa-l(gZNw&ffbz|zbrjD&koIxV;_Nv=9$(*IE+dR2uYFM2)E2b_qO<Nb3N+jEC
z@6u1M%dV@RzOZg(_NR4g>fV6y7T4{nJ5Z;bR8?13*I0MH?qc0dh?b?@grV=&jjelF
z_j}!ox;N^{H{o#l*3=R8BkJc=yVm>FlkH|K<WSbHpBz-bJ$>`!h<a^(O8w;et*N1D
zV<yk6A2WGT{l%;$^(*WDob+XVR$58@zI3wvl5LAD%b)5G*7q(?GKJ)uMYcrpF021;
z`ic7b`puJD>O1Oh*8f)jXZ_#xd_#YD*)?pQygl8aVR*yH2KR>X4gL+vhTw*X2BBec
z!}NxE4NDpd8op}S(ooXyQ^V1QpBw5Lnj5Y(bT$0e@U+24_q-uAZS!R2^x|x?Uad|K
zKJ9#3cKV&uUZ*FV4mllnI`#C2r{|si{B+Uj;?sLh|9txF=?Up=r#nygoPKoruhWt<
z1I`RR<96o#GZW9moSA%P?wPzZE6x<1S$}5BnUXU<ojG>KbmrWdjx+bqyf{O?=bI;U
zjeAq~rY=h(>xs<u>y69O)=wr|`LeWOjk3l!8{Hc{8hsiSje(6Jjmm6~Nr{cc*=dbg
zjoFQ}vAeW!MdQ-Ob&XpZiyODi*wXlYBiSDvZ&c};F>Y_%rR!<@t?^0Yku0%fvJJe1
zXnXp4`1V*eC8k|Y9n$2|G^%M#)3~PbO(p5drr7GBrV#j^$6<F8cC)d&2)lXE{j%wZ
zX+zVtrXBG4`=+B!Cz~?hTiXP2OH+H(^`=`*kKpx3)2k-_tle4nvtDOEJiGSn9(a|*
ztNLssyjsp)JA3==?`QdQea{U!=X~zXa}m`c@EUtA5MH6@v~}=0r#+`T_u;vj=jOxf
z%cjrH6`l*J-g0g`ynZ^@TH9KC@Lc7&Q|Hc|I|#2!@QSE@07E`GXVq-gJP2MxnnyOj
z-TZ#De{*niWb@?akm{MuGn?nZJFj_F^Ty`l=91<^5QS79hj(4GrMaj1_vU|^TWiOj
zPp=w(zO{BDyfyF+KOYOP#PeC_=bvA4ek7Dz4DW*TU!C7}{^0pz=WEaVH@BU?hPk?+
zd-wdq^L)$eEpN8G3op+Wc}s9hMolC}5!LY!C$~&#$!eL?Vu7))YT4HEUCaKKvX&E&
z%hYnN<qGuO(R8!rRnyq>W6%HALgset`9E3)HOHQhhkmaxg{1zkuP&J0|9<&5k86!@
z8Q<#Ps%edDozgnK_3nAH9OGN2w|?AO*t))Td+SfFM_Xgh|Eu+nmiksxO>6D>R`R;k
zdabpq^-k+=t<PFtw6bm1Z3Ef{w+(G`X&VKv^s2FKWWD*fY1*RU6;hoB?~JzKmKkl@
zy7_HO+6vm%wQYfX+Bz~#-?lwDH?nyr^xNO|E#xe3BU5qhd~I7(TU%R3P1kwS@7nqD
zHcNAN+ugQ5+x~8gY>`~(cftOG(}mF&#$AZKfYW^;?ZO8a=3lThufI@y0jB!G#S1+b
z9$aXxZEAXQ;pGMEi?3aL_oDn_;6*Z4-9_C+{@jNb=U@EzV*bVAiy_r}FV<W<eesCt
z{KY>m4!tz;(p#7QuJyYVd}&Hc<RwdU;-&7k*_ReyD!z2}Qa8LFT>AY|zsnAnT`rHh
zJmGT0W#Mwx<>i<6U9P_TXWNy_H!qXzy0!LE(~HY}+U?t2+uv_jv`4llwP&?YX<5*|
zwEc)_Rr}iZi0W_K54N9dkEv^JztkRv%fsB>?~41CiC3ny1YJqEl67VFm4#Q9URiNv
z-IX1X_WhNLE2pkBU%3SDo-4mzd3uGt+VASGSM0CKuD*5k-K&bL5m%G0&c3?j>Zuy?
zjmf*Z_UittN3T|1y>|7lt4xQsZc59rj@H_DI|4ew>S8-mJ7#vwhfj+;KJQrGu@yeO
zbyZvUV@F7J3=F-$qoU&ooYDN!(b@5!<M)nN9m7uzx;ErmMTh*_=hvpREQ9yjYn!hX
zU)y)>*tNUYtUK*HW9rhYoI00Yk#_c68FX!IX9bK+er@fwIh~6;Kkr=MxwX^K*;@Pk
zm0g`jI!|`icAo9L)VaUI+<B|>x6Xc7|LJVL@*BLpuBTj|dVSUPjn}8Ne0}}9>seQV
zt{k}j*Hz>7hU<^6|8f1*^=+`f>0=&Xwl|M3k21e!o?&jS-Dj>dUo>}^Z<ueJojRR5
zADRC!zk(NUsp#l$>2DckdCL-SNrl%3mH{yA3`<D${*L{yR2Fy6v8=R&)orkBvwUwk
zXsLldO%|Ivv*ng$gXJ&Fpc_MOxZD_Y<Lw(>H=H^{ssnC>-k8!7eS>_8sSCJ~ctdw%
z0YsnPSPALh!@BwE#+Dn0Zv1xR8N}O~T5H|A{JU0kZSE@W+SPTi>v&f~*R`&$u8NL(
zU2k-c?QXt8zB4v;P+oUfx6nPMdscTr_uB5V?vve9TI#yVHrvwO(tV}-VfXWH_NLoS
z<;~!m9ORF@nS68V%_TR#z*o`D{T*8&#cXM<HQfC1=Fyu+OiON_ym|4a8D3#^w{HG+
zlf1*~!s`CM`S(r9t-iO&8Xk0O$SoOudh1q5br5`(-O8wmxRnmC4{qhc=X`i?xK(`X
zd&sr_Rt0n+U%lzpnOmk?7a_WS>)x%Ww_e?{>N#SvYj~~45p1osYmoJf>j~&l)*ms&
zR;zo+kt7DXX+3Fa(|hLiEa{nHA?J++Jzw>ZV>>zek@J}?J+EqZ!keU#_{X08J>*zS
z-bZ>CXaB2bYpR&Ds;9oE3ErD0Ux4n~>du}!)6H4rjDiezujf(Ef0p-qPg**2yYFq{
z;M)^#$KKAk{i<f>?U}dpZx`PF>h|31t+)M7ZNFU#DKl^HhWOa+6Sr$`pS`_)(#6{!
zrEZ0@d2(LRb=y??_;zU8U$-T92Hbh`&ebe9Z<`dDI`)ox7CC?0n!0`xnU|nDQFp|1
zulPF|HLsffuAN~?zViWmo^@x%osjCU;C=V}raPPNY`^n8eD1mMAso^6-I;%`0;02b
zuH13C{NcG7mOt)Hyh8fy!0zYQLaNtyl6d2F(tUJ&z}=AQKk)O)8ze<r=Xh6>v%g1n
z_pQ5AT0Tm3zZ;n9e|KZ*#?*1GfvJJ1Bu^&8GW86{v@tx>$@F2aGgfc|*@n3V%}*aQ
zeHkxkKB{E<Gr{ZtxZyUCnajS$tm6hTJ2*RrVcJ=E0t*LE?E&F-1M>{ta65ppf;70y
z&kO-sc#nj)9lU$vUVDf8e`{~Kz2g<-U>+ne{e9pCf0hDMZv#_55E@(#V%}f|Gee*W
zhy&xv3}w6-DdWeCWBegS2`MVZiwR`LGipc;W)w^q6TpNs6PZZp8wDxR(2Ze|nK&i|
zx|5hRCJVaLp{iy!lfleoK42Cwnan~+S<1{|^vp+09`h;l1@jq`577$vw2~=cikRih
zdS*4V5k75VzG5~rYnUy}T4pP=j@br%ikS_}caT!be8c<z(Qal3^AlrW_A({RKIn6R
z*~uJ&zDJnvnWK=S400S}_Auqp_c-*efWDQ`_asFBg6=QO&x{E^Rl}!R#t7@Tia85W
zGgHHyXX=<1rh#c?8eyHEWiB&UnRccNx;L2)riZ!4+=cDn9&86sVLPy8Z!x3U9%c-C
zk8x-3Gw-qwV2k*b@n#<~KI~)IGM+F&>{BL${fmiXUoZ*mOGeB7!=$h*`vJ?bnJmvv
zWhLx%whx=lTCp=&Yc_}N%g$o^v9sCN+4<~Xb^-ea`!W1S%qOfP`zbq=UBWuCOW9$p
zo^@uwV288$><G4ibzzsWQg%5jV^^>v*_G@lwvhE;SFv8~YIZ!kiS=enSwHqCR>AIN
z1K30C1h$f$$ev`C?9Z%<J;MgF=hz_jJR8h*u;FYE8^PXXqu4*$81^|E%f4je*;i}=
z%W+98&n2^cxD?ikOJ%LOG}eYoXKgth+n38=`*R<#1G!B0HEtR^h?~yZbJ?r|H-mNN
zX0lRlHY?-iu<qPk){C3Z%DDxsKlce6%`IkQxKG(wZV4O5<+AbI=WGI}XVbWqY$msg
z{gB(hPUAMQ+1xkmEbd!&4!4V)%N=GHa7WpNTp9ZjSIK_Don#ktCiYXVn$>ePY#vw7
z=5r13587wgRoq#&h&#uwf&VR9&s}7<ahKU|xOTRfyTN|T-DY=iPgw)^jNQro!IpA=
zvfpzr+1=dV>`&Z3>|T!H_Hh#K0B6M=<E*)I&W8Jiv*k=&U#^B5$klPLaShz-+<9&=
zcbT*2u5d%R8=Q>m;#|3I&W*dtjpA-`Z*o1{+uUt#G<T01!`<iJ;T~}A+^?K3_Zt_$
zJ>({EkGP54V@}Ea!3A=EaX}o*hjO-j7&m~A;OzKF?sYzz8_dUYZ}4&4a6X<J!D~4e
zK8=&|>D-&Vj(dyG<lg49I1hd*r{F*2Ch*yulApl^@-sO#KcCa^i?|SeF&D~z%0=?I
zTonHq7tJr_V)<oUJimey_?27=U&y8NtGLPhYEH+m;XdHka+&-(E{k8!eaL^y&EO4O
z4!@I|#g}q(`0u&7{4Q=D{}VT#Kfo>Ef94kQ7r2l3OWenNC-(_|kNcGWmCNOya!Yv|
z{&T(`{{=sQFW?9A%lX&&mApN_ns?y8<Q@4n{7`-!KaAhNJM)|P;rteU1iy_R$$!JU
z@!#^J`0f0g{0{yt-oShErMx%4i}&Yu^Aq`>_&|Oy4^Ipo%`#yp;2-Y57;q0LfJea8
z|4n=n(kDZDGx#BR6`TupflG-3JQWx0&G!n@S3zt)Ml82C_J;T?NIx)?WwwI;5EIql
zw_t)3!+b}C_y=$y^-Jne>ILerRGW9i{3EFm)KydywUf%Zi}}5%Y1Bp3Z>cA#m#O!u
z{ofUbA3+VLPNS}%enUM*ZJ|B|_rUzU01tqD--CaL1qXm6-47(`bHJa$C14fUyS@q`
zZiKiPya4V8$?~rRuYhMjGuR2<1bdf%@A~;2(jP+l-ykVhGL~h2|Btx0|6oWb<-P-w
z?ZXcw)3@Run07D}VzRxYgDliN%K)wZ!>KfX?|8Ez9t8at(ezx9l)D-n0_p2OGCjLM
z7l_Nj(O?be2{wUbzS_V5h{^K7<tT@32;xpi4+9^AIGs+geM3y1N=M?qAzgs@^>HxW
zVDEH|fS7Ery~F*V#`E9X=@=M}Y^Ryjb=04zRaEj+>?|1HJ&197!5I)cc)<4v91DH|
z#(;TX7WgH&7$nPo3rL3B1#W?K6G*1F1^mzTavfrlzjwWn<@D`;<i7{~NjcBy@UOiu
zmeV`Gz1zuXNH2xq{6Vt3LqW0}CxJhK^FdM$DW6RL3t0X~K_2RrlkLxj`WfV_g!JD1
z%m2xZkk1JDz6MW$-%)>}lI7P3=>>nozc@nqWsu$iaW!}atOu`yz4LJnVlrL5>oY%F
z+&^81bh3PU{qOaE5BlGP;qH0CIVa?sItD&N90J=BiRaLmY)>T4f^^cq@GUW(L*o@R
z|9To5Xxy9s35@3<4EG%T9b`SpN$&s5ADOSd5ch?2GQC4UGT+vI@bpSZcY}Bc=t28W
zq88G8y>5k=Y#+UTNAvBamQ(*lt*16quTURRUr=ql#OXR4EiPAkh@D}2T);QU^nvdG
zoB01!{%Bg>|I>J$kAh<t%nw;U??d^$<MpJ&PyD~yd-Hgk%Kz_wjeA)8?0KJgKF&bq
z;e;g9;Rq*FM3T&8o)a>KWU3?~Bt--Hlq5-#Od$zLl1@lAG7}}g=e5sX>)U<4eSY81
z{kZ?U?|mNc=lgZNuVG#5TGv{8?X}llC+eHwYm(nG>P7jwq|N!$K3c9PUd&^&o>^{S
zG(IZoOQ$D9>rcZsq}_SZ^pdE5GwMHx`h8Jf9QBu?{uaI|_3iomw<vrp{z1IiuG!yo
z;$j{=81+v?{o<(KjTh_j@A`2iTF$t;q@7k#zclJkMSZ!NCHcMZqF*cVqF?5GJVRRS
zZ)U&DewLoc_F5(FG>-a7QUAZY+|Q%+E<}BD?UHtzMg22TzbWc3Mt#aXCH-%K7yUQa
z+Z;D@9L;epJ&vW<*PNf@XisbhbH7<tMUoz+{Tal?aUeHEk{%~*`WJ`~CT)(F*{-?2
z|GWKrG4;fL{svy`zpL?)<wpJ1s29f}u|Mo0E&N`*SpGr$Nc?fUm=_oEV@aF+Hrp*-
zzH~YBIA^wVjdmu{PNO=q^bFoS9-009Py4xq`m?G34qmL+hj`I{vtK(&zexT8{6hTE
zXt`ga-YjP>w{-cx_+5!;_j0tnS^v*c?U>uiey=RO%5q}xqF(8AJaMrdOmF6!%QyQY
z{+sU#+7W&g-W;Fu)EC>c5B`1pFuce&`}aXK{~BJ@uU)sKA5Eg(>}ToandQypl+HK%
z`R~@t%>SQ!>Gc-#_#^shuBSP#Iz;<xjz{T!{ipMzd$gT__{}V51b!QSJYKvHPQmXc
zJsU5!*OI7@NiNwRUL!5$)2gU9_md6Lay#*&ox{=m<M{owcLskLe>Li*`%2mmM16A9
z=irY~&Rk9~x?HjUoFHC>{4@A_qTcLxqiFro{ajByu^ug>`CX!3^joyohx7&fkf?tO
ze~q-cycwj$^346H4(B6xqWNOKFTEYi?PG4Y|8%>QK3<r|g%?@A7*F#!*P&0z{wK~0
z#c|?w^2PQr_jj|Nc^om1E9UX1bbtTT{+a7z&ck&qSB$H<zW=A~n){)7TsPYl=T-Wr
z%(ti)$0?C6y*%?cU~Z>f^iQ0}9>=>WZyxW=aWIb)=6-ILKTmmaJi3V&<F3^!Sx@nP
zB#!syc8H6{#raT>_Qm;73f|m*oAG%&hxAj?a^}38Mq0E#FB)HjuS~gR_{ecO>Q|&n
zk#b_5ish<uN&cE>{>S(l)HCD#DJQmvIBp1U?l<Ogzo5LBuY02YAYPO+$MG0xao+nY
zz839X!i)948TDM6lj;$7Mt$k?I`h0ZNWQq9ksd8~7rrs|UPzXt=J<Tlt?^<#I^Y|U
z?t$-we;offelUJCekA@GyjZR|9*ane@p~ID#?5TkZ0`f&6NsD3G3%E;ul{%EyZ>&z
zw$ZNGKHo%_Uxoc|8p}COT8!f*yy&O7U2jC=JD(`o9#Vsn{>I>EQO@j_SdY1+lZY?I
zSHQ2t*TTPtuaDn|7wfYPFV=4#-aLOO?alKk(~HlMVw{@N&Jlb^yqHhs=efs8i_f7G
zqjB?d-89l-oXzrP+AMFjXVx>@GwYknHS3%8%ywR&{p0j!L3H_VM!gx|K>8H<V!K|z
zZy|jXzY{O|btvkO<JHZ~1H5SOy1{2;(l<zZ@VD`yzvXKUOX6mEGwmauM!6h(HvZnS
zCHr3u(sz+=jIV-kgTEW!178>458nuHwlj+K{iMy~v^allNm}e*qTdtAZ%29-z7xK5
zzWAM&m`|nS;<(b4^6SX&ix<b2LHK`)k036_e+*tMZxY_@_ZHI6kS^W+zgw=k-|eHG
zI39e5pH2OWd|rMLe~Pr|??3fpA^Dfce-&?UR8lSr|2pYzY3#%JvZViouM&;d!hcA*
z0596*2~v^$&h(|@qMc7D-y>SyoQLMT62~{O-wurCKN0oja>O`^{bF)7J|pTyzdonk
z$L>gx{o_T_qTh?~Vt;ufnl|4LR*@F{HRoyR`P-3sDE7P3`@yf&6W6DH$BXMKckp8U
zpRCGU$GZw-=_`CHUaUv;sDB_De>9pN8uc^q2Pyv?{(JlayqI@u@jsCk*T2H}1EjCw
zkKskX&Hdpt>0880@84$s&HdNhzs>PB*UQ}h#s0vTS<=;L`~Q>Y>z+tId{KW_)c?DB
z_mFR+eKGH1@aA?9X+P;^(fS>uzE9MTiux&0KNp`s`PZX<9X^fp=lE>AIe*OdO4l#l
z{=aL_tY5l(>GsU!iQ~H1-aF~XUGziD^D2MyX1sKHvHo{c&a8j?uafI$`)NmfjyA{X
zf4WXn`Z~{d)EDza<@cbXU#9nwuFLXL@gl!W)ZZ2L`FK(O-l!MnUw^M}w$p%oaeQeK
zE!Pq++UppNca5g|MDqtl{S#3?F`EAzUd)Fh_(u3Fey=LNM-k&9u2Yp>FZ2E0yv}8g
zk9qyd9H-G~CD$o4%a)9zc^$J`dP#Z!%W2N?M&VoI&9v#K5`T!edHvt~eqbT-&cwxa
z|8Dr#NsDn9BA56zq{Vod*Z<Ay{^Gi)IG%hF&EJm~`?)wS^`RZ{eZXM6c^&o#@_lUo
zi+C}v=6);o<G)|;FI~^pl=HBEXiv;9v3#@r()G;m3rue=PrPqUqCN9CVa7}MBaP)g
zL%BTsY<x}pi+J%p%|d)V(y#u57vn9yr!cR>7gBBo<w{>aH@8bm@>h}n5dM9954;$k
zVR&&J`VG8TPw~0rBl5+0{^xk}bH*O>_mKVuFSgTRyx4xn@Zx%dS>K#jP3|vg|0(=8
z)HCzN{1n%v&2r|vJV80Je6w6;Gg<oaZ}t99)01iM<lovWoi5$J=;uEjZ;NRsOgrLp
zjOed9Kg8!$kv9El%3Y+~Bh7iA!FR)p_tU|6F)zm9#rTWz(w6^P@0W@H*Y@E5FL0xZ
zPg)1X{Uj>)ki=^mkpw7WI+15J8<81MlofZH%+&Z#3DPX6@PKkBk?%Bv$PuV;?}>}Z
z9W924q{k2mNp2#t?jfQ;MM{voM4r@rM8-fxN~I;<GoV9yTMrO_2P#rJ?aAE15+ojD
z6L+_`p(15+mka-?719ew9B~yYQW@@g;XMaBr0tFb;ya)s<!~nq*Z!eHYT`^HUI-N_
zk4H&6q#4c>A~T`F9WtqutN|U;4kL~DPN;ClOga%yAcKe(DpCQxa7cxLEFw*zA~k0D
z3ir_Dz-F|qNX>bat<1eO<<Lb^dH8@-5w?^n!&cmrqj0B9b=Za_C{kOgCVWt;4cl?g
zjv}?^{v1Vmh&yx??#F2WJ96)iB0bE~6z<L`gpY6+kHTF#&EcagN0GX)1Vws`wiT%>
ztt#BN(++m0C51bBI>MgRR-|6kQ+PmB7ubig3itVRhmVu5Nd3uCqyfYfX`s{(jv&R+
z3@Xwn?f_DxC!`^8H1`E5-03p{ZXkzm)}SJ7BuC~Bozdt`(irroP~kqEap=#W!W113
zw@DM>A?_nmq;I7u@H_4&;>;2%()ZGIc$9mJ6z<cRMf@66cofDQ^bM#;zjJpHpKzce
z-Qf-+&YtACXjz_zR-nRX{rPAODpHKR0D9#`FjrnoJP-2!IOL_UnY;`RmzNVC0TpSa
z{04dyWUb|uaJ2jud{TY~j*(ZxvGN)?U49QfE3bt!<aKbayq>x*LPeS<Z-5`l8{u{y
zh9XNlpd#&*H^W`>79w9lMcN~8g<*Lcl$0G%R(3%}5&zLlg^Hvpd(k>nxC?C`bSwLz
zM>#;;3)yp(L(s1rh5_XW3@S%qNI3=@D#u|XrI_*skeRHUKsSMkRH&RnH-(IhavI$X
zGPjj8=oXN<t(-+a0GY$edGv#jIjmejw};GO<r2CBWDYA=&<{iAuyPIk2xJZ`H_(ql
z=CE=T{TO8SDu2N4%55S&AhTDwgYE^Hs|q(?N&O%*R#D;8iVmkJcH&c^BE6tE;atT<
z<VC1RixoF|2~@bZ&x?K)D$+8=kA4j*(sCsTUsqz`1|^>O$54?zR}$e?B^hp0QsG`D
z9qv;y;X$Pg{8q_<SCl+>RVfFrDdpjHr6SB%E5p0hs<5V79oACwVMDbh9I4i3S)(8`
zO|63-4Vh_bUGx~JNaNLdaEjUh&Qco@pA8jhiP{*hQVWT!hKjUKy&wG{WG&R@@ME<I
zZdO~u&(zj%o65al(ss2S+^s$Y_oyA=ezg<)M(qp_t6kuCYFBtn?GArbd%~a8-mqBh
z3x8Jov8)r2d8-b9XVpRQiaG>dRfoZA>IisU9R+Wyqv4<G7;4>)P}9Z{F|_eST#)&!
zO+<Sjd#g4X?SqOGt4)FBwP{2uKt;Mwn-1$~Ghlsf7V!p<`K-->O|<7>Gi@&M=1`GZ
zX!GC$+I-lG$4GEA))v9O+G6;)wv>|nAX`COh8_*s3fgiwMtg(ESg1(jw3TqS_7;&j
zP?4U~-hm6W)kGFTMOvh-fv;%q!NuBIxKvvQ-`Cc|wb};wfwmETsBMDlwawK12(rDj
zEpVf@6@H>^gP&<T;OE*d%4~&-v_snscWQg#m)btKTiXx!Xa^{>7b?<M+99}4I}E?p
zj==reQTUB^3?9&q!-HBeJfxj~-)g7eVeK?Lp`C#zwX^V)b{_tsU4W;xOYm3i3Ou7-
zgJJCkJgePgx#yrFo!9<A{{|K5f_58y5h~Ip?GE}fWQJ(mj3`~zRCrC(;dRXpZ)i^V
zyXJy7H8)gsufj1La*m?=(Ke_^W%VE|r^mv(^mtfaPlOfpWLQy8g_ZPlSXs}6RrE5j
zs-6R@>3OiaUJlmK%fo!VBD`C#3~TCDVJ*EntgYw6d-R&Hj$RwytJi^b^}6sry&kNm
zH-Po^MzDe27&g=kVI%#1*g|hkpNk-KPcK5ZguKt{E#Y{*HGEBP3*Xh-!8Q6raJ$|S
z?$kTMU3zEurQQYZ(Yw;ZUda2S-W~p+_k_pv-tdIp7oODn!BhGGcv>F>f7OS;Gx{*<
zh9TQaAAvpx*<Si6_?tc&UeL$DYx+3&hdv%^wuw-;O@=nx6lk|igAUtt=&{X!UfV1f
zu+4!%+w(AFn+s!Y^I)89K8&|5fC;umFwwS{r6)l}O13RUr$EjOZOh<L+j2O}_6D46
zTM1{_-hwl2@4#8M)o`|L4V+_p558<$3m4ed!G*T<aFJ~TZN388`)nKG65A%Y)V3ME
zYTE*r*|x$@Y}??cwjFS@Z5P~T+YPtd_QD;ueQ>XBKm6Ku03Ng*f`@E};kULU@R;o=
z{MmL4p0FK<CvC;>l<fq}vY&$G?5E*f_A{`&{Vc3tKMxD+7hs|N5^QR}0-M{f!3XU(
zU_1Lw*xvpJ>|nnQJKFES$L!q1D|NN2u(w@@{q1%*#O{P6?JhXR?uO&-UO36_hcoO!
zRhDK#jz9KT_>(;z7TXiy&-P?^!k!9G+SB1FdnWwFUIw1F=TP@o$Sktwp~H|_WG@HP
z9OYq#qaw_7REAlOs<4csI?Q(D!yHFVnCqww^Bi?xSw~%1-cb)$a5R7w9gScmM`Kvo
zQ3&fh?uQK=&0#}F5p3jW2@4#pVPi*IIKt5mj&wW(r#L#&x2aH(ra3yHpMjjAIXc5<
z9bJgbfXpRFSNMXXJCV6ikzRE4M9+hY^pc}DdOl=!Ir_o{j(%{VV*v3*kYl@J5PC6W
zb~%QimqKQjV;EfN7(wJss7P-)M!|O-qv2Y|82Eu>99-uZ4?lEFgzFuX;YW@saD!tS
z{Ma!aZgk9`olhWV)Q(x`Pa$*FF$aF;cph$X%!Qvj=E0vG^Wh1{0(jD~2%d5*hG!j1
z;d#e0=y5KGUgsOo=UfT>&bMH|`3?*^SHqBV4UBcZ2jiS;S#CUJ|8=fICqhL^a;}G!
zoEu<e=SEn?xd~QvZidyITVQqPR#?Ni4dy#{z`LEhXrU(L80*}Pt_?ZHI`_gs&V6vO
zb3Yv7JOCFu55Yyw!|)a75xCfS6fSWdgG-&q;j7MKxXgJ1zUDjympf0x*PUnJ8_u(E
zh4VaI>AV0xabAKuoLAsZ=QX&?c>{juyh(qKKxV%44|v*n8~*CN1J5{RjrTjJs&NGi
zD$-w09jb<%hz2=M8cwtg@`=N6q1}*iHr!}GWNZyDIu<gXh98{>Ir<qvbQ<JXVZ@@#
zL-r0M9$gVKl13srA2O0gGP)+@UCBsA*M;maMmoA7<lV=}L>EEceT*{bmXPxwBM03Y
z@@dq_L$`$-ZH#j8A)`F(U{oaD5pv#cRECcjRbgkNI(*c~hh2=Cu)9$k_Au(eo<?2R
z+o(s~K9DmjqXB%`XhdWIWSbg|(TgD4)F?zRhHO*ge)LkvHZ_`~mqE6vQG{L&*``KI
z^c#?EYP3eLgo^a0(H8v{RHV0!c5s#P5PaY0NPI11zcV_a*Fp9>qceIvWWO`Ipf^DF
zJEJRlBV?W!-O-yM?-52%^k&F@XY_`<jJ`y^gq(dD{oo#B0NiT~g8Pgi@JC}9{K*(W
z$zsTiGDg8)jnVLoF$RW>apazbigeBxk3J81M>ZzH3&vz37a?a*#uW5r$QhI|4Sf~z
zer-%gUx%DQ88gtoL(ZU#S@4!I2mWC^5C1gg!rR6?_?Iys-Z2(H$+ZY3xfa6|*HW0_
zS_aFwmct6JH(+(wN?6177R-0O1MhaNhBaMlU@g~su(oS0OTPzlzT{d58@blQ0@nuE
z*tHQhaczQyuFbHiYYS}d+Dfe!kWZJcZLqIv2YlSM3-)vEhC^I?DKiwZ7rXYsH(mST
zd#(e---jGsU5DTYuETJh>j(_Hj*@#8GPbT`=<|>>PuFo67gJ0m9<nFKoIoc+#v$eu
z91wFFJ{fa{_!!9N{g|`x>6r6Gra(oS8gl`zi@8MPL&&U%xq|)@as-aK22aJ@Ao2@j
z>&M)LzsCFl&&1q@;g~xx&drZ<q-3`WQ`|Z%>$bykZYQkdcEQSSH>~3J!m4gRtmY2F
zn(kOw%N-Ak+==i3cQS10PK9mU>9DOk6F%rJ13S5M;3Mul*x6kUKI$$HySOXD$J~`+
zS9eu7+Fcz!>CT5!-8JEKcWs^PwvhKVcOCe)yDr@3u19=3<jCo608hIc!C&2t;RSag
zxfdaG)qOww-Q67CbQcl71(~1jmhew^Yv}c~g^8YaFv;@}EbHkAD|$M?N}kTJk*5oF
z3n25#(-qwWGOs+{(M=&&Fg!ic%^-8k(;K$%^d(XR86{6YbW6wxcm}|3o<Xp?X9(=!
z83ucLM!;U4QLwjXH0<LU1N(Z$!9kw!aIj}09POD5pY%+DV?5K~M9*|M$uk2^_RNAW
zdgj1+p6B5*&s_MLXC7SPnGaWb7Qi<>i{M+H#qe#<QuvN%8T`z%oZfDMyw`i)KyQVL
z^o3_7dK=`d)$<nI;duw{^sI)vJ!{|r&wG?P2swB4tc5P`I_UPUhaT?+==E-dKJO;z
z_ilzk?-m&A-Adg!$o%wfgEhT7;Jw~muz`0sY~<Yw3%&c`!`}U{llK68#Cr%n<~<C1
zdXK<9-lMRu_ZXb(Jx<FnLXPU*V)&-_1boYT3cl?<4d3yefvdb{;cD-B_>K1hJm9?q
z4|=b_<KAnu^AqH3)_Vi$zMIhI`vcm2x1qy#2ReN+Ke0^lsW8>2!!(~Aru&>Q!{>sT
zJ~zzrd0`o!A9nEt;bXp7*wq&gyZI7f4_`9u=}U#ZeCak>>J3>(UnaUQWN!G%z+t`|
zBEuo)<i0#O!B-AW^Oc9s_$tEbzRK`fUsX86SDo@RA)j}A`Ea(cCY<A|4Hx<9z@@&r
zaFwqfC09eXtgiw5*4GFg_BDpz`3m6?-~I4=Uvv1guL$1owS>CAHFa%}QS!Hi4u3l$
zPRKPG|3hdO<V?oj5$%SYCHgy|gOD>Be`j<o<Ot^Pf{usmx&E#&)8Cy)7Gxy-Jz=)L
zH>~9EOT04VXy)$+tNI7PYW_j6x_=1F_YZ@2`$xc<{!#EA|7cjpKL*zKkAn^T<6$%Z
zL|SVO*}MIdVQc>sB5fd_q5RX(?IG_Y{^{uckYl@l1{~<01)uWIAwC|m75vYmpM`7%
z|6KG;$X4*rL(hh61^;~XbC5agUjP^Q7ZF(qIiK+_MlXh(&-j<3mqN~G{L9eGAbY)k
zIeIzdy~F<o`a{U40RKw(k^e2Y)&CChFCa%(|7y71zXtB`zX$jF*OL1c<V?fA4u0)l
z55M<sAbu2bWx&4?{^H+6<TT`H?B5Kp__q+b3OO44w?Zkf4LSllpf9kCTt8%62X>=_
zkZl^+i%x<Z2Lk)hDUkgrupgZU*^dGT;5~suMCw3}5`n|$x{%{-;0U@UWS<HgML!1F
zrvk^&-5`5Y;5fP$<Wp^+7(D=TWj=5MJp!`50;k}tz-c10A!8Ug13wI$g}(;Q6F&nL
z>0;ml`V!<iM(`3^ha4G#SI~CI><V6k_XKai!r)EVH24R6D0mxA58i>#2KlKh|AkzI
z3xhgb9JIsNf=;+R=z^<*ZuqaD7k(1-+c|H99IJytxHT9HzYfO31HnZ2V=x&O2UFqc
zU^)y3GvUQx8F(d_18)WM;O$^JsD{czTc{$82~~#PP*oTkstyxE`LJxLCM+MS4XcFe
z(1)s!bGA@jSSM5u)(bU&^+SzdgHU7GFjNRThwg`uhML1(p(5(`h8)d8Ezx};=VPJP
z=zfs*yHHy=HPjAH3q1s9hdRRNL!IpLe1r21-^=|V9pqcMKl#=uL#iS_Ayt!Bz<j>@
zc!KY~zK5Nq8fvC}K3BkA(HC$9>}~xuX}B%Z{s~tYCdPguowHAl-69!|zwCSX)PJwz
zE9p^33)s!^0PN*x<@io|(wS*LF70tnvmKYda!!X|J7>UeoU`CT=N$Npa~b^AIVJWu
zpWvp!bI$4TH|Gp^(K!oVcFuuUozKJT&bjb+=RA1JIUoM%TmTJY2kpcdyP(h53q!_!
zm|z@&DTe4tu2GD>%QywA7-wxK`6RU{_N4T%u^2vLEQOC6%iv?ia@fsy1NJah!d}K(
zu#fQ$eB4+K`x|TEK;u0)*m#51h8ip3aN{jF(s&0xVXTHv8f)NKV;OwPm;omk)8Qmz
zEp?wZW}&AVbKtY|{G>FSo}ZLnpywy0m+1LPK8x)@FJbLY@|ml^ILRlhb<};^SP$Pd
zHo%XJjqqdE@g$##PQlNOO+>aEo8gy{_5IptO5KCT79!snTcPIK25qjjly|sxpbghL
zbc|~k+T(f;?Q`u$2VCpXA=h4XoNI&a7d|8Gi~WU92m4_wR|UsqDG;;Ab(ypG3XZE%
zZcIN|HfE5+C2x1{bh+d&-5<MyavRT^@IlWicY^#<gs*xs?N#OB-b{OAIV~{A(OAw1
z^m8<mPX@jXG?RY`+>5>*Xzy$${~kC<<W}G>dowu{tUx>~IMvlm&JI2UbA!*in#=Wr
zJ7J69$L{9x1Ho19B6)0Zc(6!*DmXIOM*b>zAhwPCeXw6l8~G>p>o)Q)!9zsC!Naj_
z<?F%n@b};mcq@1`_9595(n1f(zR<xyC%Fdt5&1sYS#Ais%7ck_lgCE*ROl~zcX=x8
zCBH!KX!-8AYH<$br<7x{4&~RB<1n0349}&UfWM_=+Vd4H{ajkUVoU!GI?^vfBmHt(
zD<v&+aiEoQSLPvGE2To_sn{OMJz1yWy;*1AeOYH={jBq_Vb%p$kaY<*$+{Hkp)}39
zf^L>|4YtU-0UyY^30r0T0o!EVjvcD}mi2@*MyXIHOBth7DwD0es=S~5gmhd<$j#(B
zX#d<i>8vs^_fG6tWpM79&{<_@ZaE^ubIWiQvr=9~r%SDpmx->HmnXT@8hMq8+?{tO
z<Wg(pl_PRbUKy@*Hp!FY+-eI-y46;BD!NUc4j;_3$9dEa)b*$j=XH<qsE<(BqdrPq
zkNOyO1L{m_h17+4N3@XoN<=TAd`NvYFIEYuuTegvzE1g&x`OiY>W6tXJ@M*Cl#EwD
zrewVONnULtpHebj{fv_F>gSY9P<K)?LH&}F3F;n7Ca7OgGC}>Ck_qZJluS?$QZiBf
zo|1{`50p$)f23rh`V%D+)t@PusGg)`qWTLZlhxlSnXF!<WU_jhlF8~-N+zq<DVePP
zPRV5T79~?usccP8imH^&L~CX9q!iUwwl)z**)yRO)hJtzNKDx>T=5N*-OE!6LX=EZ
z<0zS`CY0SrB#Dx#Y6>M&)ig?`so9iFQ*$Yqrk15-ntB%{)6@!-Oj9dSGEJ>Q$t<-Q
zOV3hUP%=w>fRb5iE0&(6wxMK}`XD8<)b^CDu6|P18COsBlq+Lzs3w)mlNzci<%WeC
zs%hoUz>IR`h-8sl5Dsw9NI^IkD+pKQu8n%ACQ@Ozh<hj=mWJ{a67k%Tr93%gEq5h+
z$MZcd^4?RP=V(04(>EsaWQ|$!%REP8ja(SsAb$aOV~4Pxu+#Eoo|RD;mU#|DVK`aI
z;&~5uqYA?Hlx9k6R0pMp(q9>-OjMpx<|y-(rOHa>UFBnCyRw(3N1Ra3@GOWM%3q4;
zpRW3NCPJ=SRlQdor51$8V^h`HYGL>#o`Ud>x)!xj-Ky?Z52?SXzp0Yu)cjhyRv6CH
zD#MyuJ*`k{sddnLYa_I$wVB#NZG*N&+o|o>j%x+sU$l$bP0g++>$!R*y{_IwZ>e|D
z2k0~Om-QujL3oA!p8koxUH@ADPQR#M*Z<OOHjgdAmS@Yi-DfMbwX}7x^|B4Ljk1lm
zO|w03d&Ty?ZL5v<1KV#l)$X$AGv0Nv0(%SC*8Zrymwl*xl6{W-W&3;fz4mYIKiW^*
zuiO8!+Z+K$iX+z{*1F`c3c8k~k)tr&%+bd2u%oBr3CGipS&o++OC0YxPB<<*6sOCX
z;Vkd0>uloe?Huo%=A7ev&AH0C(Yeog(^(L98gWLmaJo?tE^pio=?m{DeNhvP=ZppT
z<;FXZ?PwH+w-~$7UmM@S<Jf8J0#*>d0q<aTS3%f|#k<lWtwvbg)y&n})e-#|HqbQ=
zKJA+6dJ(_GwF18DYDVext}XZ?)Lz$-h-!sC?Yb7#ZAs}dqTN`Sie<-Cjj4^VAJa5O
zw9qo9BVM%7J!Viui5AAhOpj{O!u*((G4E1meavRqEWA7BP{bF7PsCh^s#f7UsFJ@l
zcR@JEUBO+`-Oyd+?%?k39_SwJe%d|9z0m!J`(N&j?(OdV?jPKz-Iv|B-40LCljbSs
zso|;TY36C?dCW7|GsZL3^StL3Pi=3Zx0Sbpx4U<+cbxZG?+e~d-fiC9-pk%w-ezIh
z=kYOezD!uoSH&mR=N?~kUngHr--t*`Y=`#YdA_B-l|G@?M7SZstr6~x@UX8Kf5vyo
zcM~uB883gTzc5_hU)_JNzp=lizk|P<|8f6Na!UT5jHpTe=lzTPulrZ|H~PQu@3C@4
znUnr={#$-;AU#k$P&ZH%7!-IaFgq|muryE@elzf|z^1_Vz@9)s_)y>&k&}V5fy?+?
z0VQYz1HnRiE_z%T?ifxC=8>)(tQo8);=#7TuED{m_TeXkPY34)7X{xAen|S$;P&8w
zpjhXl!IQz8K{ezKg+eKz>`;YJjnKWJf>2SYQ>bTXU}#imd}u~!erRdv%@8v+R1n^R
zFAVPreG@twIvF}2x*oa{a>V*$6JyK9R*k(Uwoz<hxJ~S%v3+BQ#Ey&Y9G)Kg0+EHW
zuf@I{yEgWd*sZZ&#_o^(F7|lrFR|xiug3lntHe3ud~xw{X>mDm72>ML-4oX!u4!D$
zxb|_K<9fvPiyIm@I&MPTw7A)E^Wt8KTORjz+<S2!$8C+<6L%=?$GFpR7vpZmDe<oO
zP<(29ZhYnVTJiPco5r__?-*Yg?iSxZ+%JAaycp;4@zdhx#xIF~Gya44&*Hy~KS=cF
z_>1ws$IA&uLLebCp<F`Mgn9{06Ivy7NO&xvPr~4YClWa3CH$PwEF4B%#%?7@iT5Rn
z_F5#0c~lT?PwLUcUWvmK$0SZnoR_#H@twpE62D2jny4fdgndZ~N$E+sNrmA`So?6T
zq$WwNk{(U!oirqAOw!XyGm>6RdM#;H(z>Ki$p0egaMFpS>q+s+qGh&FavM~q<dP*7
zgnJ|pOdgp$A^F+lMagd^uTS2Y{B`no$-gB3mV7-~OX2+`B{QX5O8t};DV<X$rmRWX
zlCqEJ8H^)Dq(zP>DSSztS{U|VaadYvF06#*r`Anvj4w)kFtt-^_tbu=!&1klPD!1e
z`cmqW)D@}krhb_EY3laWuTl?D>W9=*slTP(O0}i=(-PBi(yFH2n^urkl-4fo(X?J^
zgVTD1r=`tJTa@-%+Um4*X`9lvrR_~SnszGfLR#PO%``dPkseG>OV3U3AFh->D13K%
zLAXKs{pqdKJEnI<_r<2BKbO8R{q^)!=^vzjlD;kdtMtR^KM_BZekuKCx}4$6@Mk1t
zl*y=+Q7hwtjE6EF%jlaiJUk@h$&ASvGc%qDznJk##_JiYGYZ4&GPY*y$vBpAI^$x-
z9~rjHv0;B^a%N6u#mxN7l9B#zBtDT5Yn|CKvwLR0%wd^hGiPLqEjTZ8apoJDt25VS
zZpz%2c`);b%#)etGJnsMvSPACenNy<SrxJh!ZomaNf%_b$ZD6>DXVK%->e~|M`umW
znvu0Q>&>j4S>I<}$qJNdQs$X5&y{(#%)iQfRAx(=FUx#iCS1m!os?Y|&dRQu&AUf-
z<LsjBcBDIJ_s$-aJqlGA9uKEsbFlf?Qfy`R8n_-S3~$cff!~K6#*SmBvoB<eqs8yp
z_MG<Nsi<I1c0^4_SIcP})iX)8%P9;$o--6aiA^GBI(}}X#A4K2(X#8%TdjKgNfl$^
zoXfC%_^%vCuJBXCak*JhH9cG{w|;IxxM^;?NaWGnp1Ff^$L3DWos~O3cUA6(xu50k
z$~~O>Q|=k^FX!IM)$-hVae2(vyu7^pyheG=^V;Th%Ilt2Q|p&EJa1Covw6Lf&iI-s
z;#_JDeHZijEXPT4gzUzVpnX`po1Y|7vc!-gE8+~PFx;Orqso+eDLh+UOigiS^E$pg
z$9ImVoW;BwNe#&=*@Hg{e-=qk4R7#?k*%AWl)crr*SCl0Vc#gW%?4wOF+O`*_MGhb
z*-Nv<_E?{NklfALN5ea^4`+WNAJ0CW{d;yWr&><CoX2x|C_{68W{jujEY4Y%vp*-C
z^H)w>ZZ*c_Ok_#oeW{T5q+;JENmq#c5!TN(i5yMd4BTRk#5+M@_>wP?BY)dqdH>+x
zlfh3p(%<xX&kjk7Kie-p{p@S8d1uA@N7b{Jb8|W3)IQtjY(iF6mMztjDvkj8?D?xR
ziq0}V*gE!^8JYKH6)<BvlWxx}?2Yfu3>*|mPYq8GkF(Uw@T{m_V8zC=)#BJrlkzSH
z>IJn4+}z52)Z)c`uF~^)g5sr>IG)wV6Ee;gzy8nh@V|){&HU%`UFQ8${9kALEH&d|
zu|oUn3pJhRc!^YpNUD26Nosr~)mw2$eXzbt7WZyuapz_h_ibiL1F(Tg6={%CRT`{R
zlZGhy(ok#|HXIwF)Zt$f)R9JEPhg{!`}kJ`_4zbeUmB}4mc}VfrKgk@(s*nFHc@FQ
zO~NKCZMY+}9ruHF;BL?k(lqQDY&!NVHUpc9&BA75bCk}~bJ+7rH|`tl#$BVmxo5Pu
zG!J_To3HejUd9$+3$aDmE6PCbC>_N8q(iuybO`s7J|Qhr#!9bY%dyw7H?S4hO6*N#
zob;A5ReD>QCcT5LQl61kD|4lHu{Fv(>0io1={@XyY%TTywhsFcTaSH&ZNNUpHe#PB
zuSlD)PqEF)GU+pH3-&p-75f6)hHb}oU^}s0*q7LDY!9{<`wH8KeU0tMzQGP)2bJa0
zA!P-3wXTp3W8Yy%u<x;>*bmBE(lKR~^doj$c~|;Lc~2@<wn#rKTcs1q9_gfVP&$SE
zf}O^G#m-=1?5uK9I>-IL=auWyZ`}KP0poL%bcwrrFDoAT3isk(RRZ!g?#8{2-B7B^
zzhgI*8uBgWZut-FPwY1K7j_4e)VpOFQ!o|NFdegDcC|ouU{1A}Y+x?#iH+f2SgsMs
z9?YvgCi^fy7Ers%LGEJ>VX^8+ISz|gXUGZaY&lVVQ%+J>$;s;ba*Db^PE|ja)39{)
zGdV;3R?ft-)Ia1h>R)oU+E~fKa<M#~`&U+Nr<B9)!pif^zY17ItP)n4=l@l~s;b?U
zYFKri16YG+{^j$mzq@&^UrnCrSBq!&)mB$4_h5CfdwE`8UF<%ro_buVuNEr}curqK
zp3&EcXY5J5>{5(yyquOYEakG4+fwmS#qaxgx@gHO(aKHZO0IaxQiheAWyP|sa=Df&
zYpF_7W=V5Ao3uhyRkL!tS+RkZddkY3V5#Eh()cZu6}xJw8&+<jT+&m1Q*WtCvN;;n
zEOoz?TO^ykYH2B+h8gW?FS%M|y(OuaTo8@*kspf2`pDy=vA$M~$K~guxsUVff|6H%
zejgx4Pm=n}JEO6IGXK0Z5*sMrj>ZPdAqt6dgRQzlt(J#d>IF-^FP9g^d3|EVKDE?m
zmiod{+hu-~6j{c0YYcW;xnEjpPo$h^`75i&S5}P!mio@B@r$Jt#T>tYr4ke#o)mc{
zS+TN~y30}pmTIOnjPz9FcL;^ix>KUL8pm6aE8YcPkCx;2fZTUqvWyj0D;q6!&QcdG
zb=gu^Ep^>ezgsFnHP>jlrB+(%Elc^dqG%85@yn=^R|88mvQ(j^?zdEPOBGqFrKMic
z+S9UV{1vTpbQxc2J)^NNwPDfN9?hJwd$dW>*pFI;XkSih=KgWjYWcdQZ2XR^<W=8N
zMY^af8Y<Gwx-BCyQL?qA+FI&itL`I~>Sn3lmg-}v$1T<0QUfhD$WntXHPlkWEj7|o
zqb&85)vF0sY@($mS!%MSp0?CfU7QMuHJ_?4i;m<oR_vKbjPFmSXLR!v>sc%JSu6M1
zNUk_6KdY~dwldQyH`6LN(<(PJQcj%R&D7tH)|hSe>N!ijV6EGW5haSgX!Z0ZEB2DL
zjF+sQzHH^bY~{Xe_26Zzrwgre3$1bst#S*ko-VX{`l{7~*CI;v>NRV*uUoO#BQY_4
zuUku7Vdbu{a#uuh#rUm=E<=;nS!1xlQlIMP{_&}9?jKvM+^v?{W~m*P+GVNTmfCBn
zeU{p9sRL1^Nr$Z1w^r=16+3FFW0pE@sRUce{-$w1e95tnXPel}V_34S<egaK4tX;-
z#mY^!nfr8^Xe&JL&{8>;%Cl5Cn>nA$+06NTmz7)I$}Jzs6<emf&79d4ta25tauuy|
z6(i-uHmYbd=XhnSTxF|VWvg7}NI5abE8EODUe#JgbxY-2s-~rCTdIzw>RO{wFQUY(
zt7olc11r|R>PrJ_-5OcBjjY^8R!<vQYt+~(*Vro8*eci9TBF9+8a20iP!v(3S4Gxx
zTUxP}k(e0qme$f*Te+>R+}4p?G0v@{%kW8Utug2noi98eH5&6tU98+bHuLEHxD^|0
zsiBq{ZmE%$8fB@`mU_x&?r%@oO7=HRdfJ+&Ph0bJzAcmfiq`^5HMW~|8{5r&wa{+9
z_uL;*Vyy1Bm%PWbzE-TY6>Dq7+FG$Lc5|=j9#xv;b*vVR@fzYVmodUpqb)VYQtw2S
z#{KvuH8k$DH|uV*)GkZywbVXK9kbL7r@2q>b(yUMV@!3zZK`@+Q+2ddCriz-)O5dD
z?uK8S&55%hXK*b_B%DF>Ov@EjnlvP6)|e7eqTH0=rbu0$r(oqyx6}+vt+dq9kl9MH
zrA}Guf~BrSlxX}~Xj^m{H!OA2DtFsbQ({Y6)+AS)sS+)fY^hXBrCTa5s(8jv;*QAD
zeA2|I63_TH`}~KMd)rcXqDqrir<zCGHI~|Bsm+$!VX0k~+HI-Bsoz9;ph-t8b;eR>
zqlzaeq?v1ZHmW3PahAD<uFR^y*ooH~OC88I*W*l%P$RkTainhN^O~DqL%OAgSbgj<
z{+mT*DOS#x>dN)RrxyECd8F=CUQ@lwNPgk<08jXTBT~n!Y~o5oK35QS^Qr#``Y2Y+
zC;O(fF-b2}C+S64TWpLnN$-dk%WSKT)Vp9kv3}SPwW7R4JtF<UuSSd2P59pO@B9{Y
z3BLhdqK=ajwPLBOwh3!uAH=UNU*uf%MXkWTLd%y{@q5Y_wWpOM+B*4&R#863ZzRw0
z3(0eom-T!pfMx1~NRQNOqB~%{^<kt>vsP#1ar#kyk9uC7tT(m)g#D_!lqITPIY-;+
zwj;c|Y{E9km2GFR>dIrbI!a|*zVy0nn7j)Av8|%K8!hZMN7r*&UnS9AnO|+ask)_2
zwCz{KIt{Sr^Si1I@&J2*eT;pRw1V_!_A{i5DRTrH#=3WrJ&qP^g9orCSUyLMeCZp<
zFj=hsIQo9p5w8~W^!z^^#nK>_)y|pE?_M@UmVMh+q~5m0WBJl{XKPjT<(RXwbe=Mb
z(MESmUDaIUfylOLV@%RJ7`^l#)LwdLe0O6Y`IGcf#z^8L^)|)|`agl#NPVqw5dSUq
zjeb!12EPaYJ^lym$4FX~yU#UJFK{)npVJ<;iF6;=CTWzbiqO~-*dy4Z*j}wzZDM!3
z53`Od<%9e;h=a_dfP18#;GUqb^i0rKdnQqTlD-z-lX<g&*k<%LY&W(aTgy5WQ06fD
zK72pQb-|8N)=uAR>XY;n<ekATVArre$dkPjSk5Hfj(2+}=|TJub%LITcQQ}2@ppMg
z(vOkEMzXAt)ElW+LGQ)~@vHG?uxpr1`U3t0wgKCQ*@?NayS&5X2Ht#Wsdp21DCbM>
zdkgG`(Z|rIy`A&|Un_fouMKuy9`DQNF5NS1pKf+Be#dC1NNquSB>R%b;q-ePUjKPL
z$G<_&@$0t3{!P-4{+$lD^c8kqze@V5e~^6DUo5GCd?_JNQO*k#OL>7|az(5VdnnM>
z)*b6h{0YiT3v6QFjaQ!_mKog5QvimsfA6+?mA1A{!9A|?*p=XY-t)nSy=+(SL8U{)
z)`lMTt_}U{&We55+ak6DHrm-Dc8|*~&Gx#bI?VZD^4d@bZ?XC?cHH<O{<sm2AMH#|
z7$(<F811Z`aNVDb)lTT(ose*!_e!vX_xS`PI3HV_;0P|qR$=R~Pq7`?*VqyAbB)14
zN8;e12Mb|ISO%7hRlurYwGumcn<PGr9dQ--is{!0jD0Tg57+U;VRATeMNsVHw&YDx
z+2nlb?&J*|3$BN9jo(6U=}62ujxqC+hsn#6&+G4zzlr=W(DSh6$?@t>$wu7r<fmiL
zX-~&4PafkQz+=N-NXeI8O*zVV=1U)@Om-hs&g&afcC$ZBcAwMY)m<s^>fx00`eFPr
z{4x9q{0Y2ha~^H(N=b@yOB>kc3HTH&4NHi-l(NkuGqZ}-$?gI6zY@o!-AYVK94EWo
zxp5QICL~Tw`!n%S+PjIv)89>e5}S}dA<->Ob{DJpQvHl!a?^}wgT-o6+@_3TX;Vh~
zw1Z0fv@ep|r`64DpLR}bpVlIClk`>QNRH7X+0Qs$l*yOMmf0kA#t$h|M-h2f%8b-+
zmuYLWXXi_IWq*@>P8$=fmHh{MeRXA=-i2dd4V#iv!<LTK$9iJoJ!38N_^_v#UwEIF
zU(5a3y+1c84z2HE%yzN<mGcJ4mGjQ)b@Mh!WAoO@WAnT`DWnm<^?z9U!Tzvx%QI5C
z#C@Rc<k9%|v32MV@$0eAv8~t_*iTXqxfr`6b(IvktK^l3NItBZd{wI<|EboHpK|5n
z3%M#>Bp1mKV6Cv$SQ{++sx$JgDR2+E!{5?Y2BLx$@6u?{(1QN`i@Nq5C=D3aebCUJ
zJuCI--#=3LPELob_gmHes}BDMA?3|BB14?9^GJVbEbWc`)+x1VThR6!f7;!@JyWs4
z<e1c1vA6C&C{70&-SbGp5q<mjXwbXoz~PUK8Z@-uBi(EFs8O?4)oQhRR;ya0TG#H6
zv>h~JX!o9vH0j!}=l#PQcO5qRk%oN-KGLRV|DIik{XJZ1aF1>@`Tt)3(FpJa3Ci)M
z)P(=FIR7VvK$U-pi*ik|4w4~_6(6;tudyosjDe^0wB-pp?WM*%$EPh%<7vrre!Acv
zkeZ;yYm;_?r^tzK>>?+EmaiAdE&0|?%$vWz#Fb@!slcosN;`d}{ydZCexAeAi|6i$
zS2pMOJawPku0)5C-<AK&)tB6Xk$g$|m-YjV@=H$QL&+J)^L+k$OCLqbRAIeK{%T0w
z#2D~Apgig}qP+q9^`!Q2mLitehg1eFb>*2rqEEwF^RDELCfWlIBqg32)SYy%XepsY
zPen`O$w5P@TPf1ddpYkkmou0W18L!bXh~6^6}qJV{b;W#ck%V6OwUN&f=FF+oeGGG
z|4$~?bue}QYb?yZW)K@rD?Mpb^jEy9@XZLn6(dKCaC>YhdH+?nD*dd=yG*6Xs7O-%
z$kr2EVtAyiSlj-8>#@14zmH2L#-%@h;?;rgCB##qda@p(rWoPD^hNZ#H)A`TGXFi6
z!T&(Z`2QV?rjdTNjJ6}TwrJg4uaa#dM(uy<UoD>DC9|ZV^s9$7g7F;wx3&A{`eMCm
zM8@%dtyg+9OONHfd>6%2S{UzPjK=_GUVla+<G*c%zt=OjgIMN&{JL23omUI7yZ*n|
J|8*nq{{d^eA&>w7

diff --git a/dep/FakeItEasy.1.15.0/lib/net40/FakeItEasy.xml b/dep/FakeItEasy.1.15.0/lib/net40/FakeItEasy.xml
deleted file mode 100644
index 08969ecf59e..00000000000
--- a/dep/FakeItEasy.1.15.0/lib/net40/FakeItEasy.xml
+++ /dev/null
@@ -1,3525 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>FakeItEasy</name>
-    </assembly>
-    <members>
-        <member name="T:FakeItEasy.A">
-            <summary>
-            Provides methods for generating fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.A.Fake``1">
-            <summary>
-            Creates a fake object of the type T.
-            </summary>
-            <typeparam name="T">The type of fake object to create.</typeparam>
-            <returns>A fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.Fake``1(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{``0}})">
-            <summary>
-            Creates a fake object of the type T.
-            </summary>
-            <typeparam name="T">The type of fake object to create.</typeparam>
-            <param name="options">A lambda where options for the built fake object can be specified.</param>
-            <returns>A fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.CollectionOfFake``1(System.Int32)">
-            <summary>
-            Creates a collection of fakes of the specified type.
-            </summary>
-            <typeparam name="T">The type of fakes to create.</typeparam>
-            <param name="numberOfFakes">The number of fakes in the collection.</param>
-            <returns>A collection of fake objects of the specified type.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.Dummy``1">
-            <summary>
-            Gets a dummy object of the specified type. The value of a dummy object
-            should be irrelevant. Dummy objects should not be configured.
-            </summary>
-            <typeparam name="T">The type of dummy to return.</typeparam>
-            <returns>A dummy object of the specified type.</returns>
-            <exception cref="T:System.ArgumentException">Dummies of the specified type can not be created.</exception>
-        </member>
-        <member name="M:FakeItEasy.A.Equals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are equal.
-            </summary>
-            <param name="objA">The first object to compare.</param>
-            <param name="objB">The second object to compare.</param>
-            <returns>True if the two objects are equal.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.ReferenceEquals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are the same reference.
-            </summary>
-            <param name="objA">The object A.</param>
-            <param name="objB">The object B.</param>
-            <returns>True if the objects are the same reference.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.CallTo(System.Linq.Expressions.Expression{System.Action})">
-            <summary>
-            Configures a call to a faked object.
-            </summary>
-            <param name="callSpecification">An expression where the configured member is called.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.CallTo(System.Object)">
-            <summary>
-            Gets a configuration object allowing for further configuration of
-            any call to the specified faked object.
-            </summary>
-            <param name="fake">
-            The fake to configure.
-            </param>
-            <returns>
-            A configuration object.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.A.CallTo``1(System.Linq.Expressions.Expression{System.Func{``0}})">
-            <summary>
-            Configures a call to a faked object.
-            </summary>
-            <typeparam name="T">The type of member on the faked object to configure.</typeparam>
-            <param name="callSpecification">An expression where the configured member is called.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Any">
-            <summary>
-            Provides configuration for any (not a specific) call on a faked object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Any.CallTo(System.Object)">
-            <summary>
-            Gets a configuration object allowing for further configuration of
-            any call to the specified faked object.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Any.Equals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are equal.
-            </summary>
-            <param name="objA">The first object to compare.</param>
-            <param name="objB">The second object to compare.</param>
-            <returns>True if the two objects are equal.</returns>
-        </member>
-        <member name="M:FakeItEasy.Any.ReferenceEquals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are the same reference.
-            </summary>
-            <param name="objA">The object A.</param>
-            <param name="objB">The object B.</param>
-            <returns>True if the objects are the same reference.</returns>
-        </member>
-        <member name="T:FakeItEasy.ArgumentValueFormatter`1">
-            <summary>
-            Provides string formatting for arguments of type T when written in call lists.
-            </summary>
-            <typeparam name="T">The type of the arguments which will be formatted by this instance.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.IArgumentValueFormatter">
-            <summary>
-            Provides string formatting for arguments when written in 
-            call lists.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IArgumentValueFormatter.GetArgumentValueAsString(System.Object)">
-            <summary>
-            Gets a string representing the specified argument value.
-            </summary>
-            <param name="argumentValue">The argument value to get as a string.</param>
-            <returns>A string representation of the value.</returns>
-        </member>
-        <member name="P:FakeItEasy.IArgumentValueFormatter.ForType">
-            <summary>
-            Gets the type of arguments this formatter works on.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.IArgumentValueFormatter.Priority">
-            <summary>
-            Gets the priority of the formatter, when two formatters are
-            registered for the same type the one with the highest
-            priority is used.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ArgumentValueFormatter`1.GetArgumentValueAsString(System.Object)">
-            <summary>
-            Gets a string representing the specified argument value.
-            </summary>
-            <param name="argumentValue">The argument value to get as a string.</param>
-            <returns>A string representation of the value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentValueFormatter`1.GetStringValue(`0)">
-            <summary>
-            Gets a string representing the specified argument value.
-            </summary>
-            <param name="argumentValue">The argument value to get as a string.</param>
-            <returns>A string representation of the value.</returns>
-        </member>
-        <member name="P:FakeItEasy.ArgumentValueFormatter`1.ForType">
-            <summary>
-            Gets the type of arguments this formatter works on.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentValueFormatter`1.Priority">
-            <summary>
-            Gets the priority of the formatter, when two formatters are
-            registered for the same type the one with the highest
-            priority is used.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.BuildableCallRule">
-            <summary>
-            Provides the base for rules that can be built using the FakeConfiguration.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCallRuleWithDescription">
-            <summary>
-            Represents a call rule that has a description of the calls the
-            rule is applicable to.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCallRule">
-            <summary>
-            Allows for intercepting call to a fake object and
-            act upon them.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets whether this interceptor is applicable to the specified
-            call, if true is returned the Apply-method of the interceptor will
-            be called.
-            </summary>
-            <param name="fakeObjectCall">The call to check for applicability.</param>
-            <returns>True if the interceptor is applicable.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallRule.Apply(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies an action to the call, might set a return value or throw
-            an exception.
-            </summary>
-            <param name="fakeObjectCall">The call to apply the interceptor to.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCallRule.NumberOfTimesToCall">
-            <summary>
-            Gets the number of times this call rule is valid, if it's set
-            to null its infinitely valid.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallRuleWithDescription.WriteDescriptionOfValidCall(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a description of calls the rule is applicable to.
-            </summary>
-            <param name="writer">The writer.</param>
-        </member>
-        <member name="M:FakeItEasy.Configuration.BuildableCallRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets if this rule is applicable to the specified call.
-            </summary>
-            <param name="fakeObjectCall">The call to validate.</param>
-            <returns>True if the rule applies to the call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.BuildableCallRule.WriteDescriptionOfValidCall(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a description of calls the rule is applicable to.
-            </summary>
-            <param name="writer">The writer to write the description to.</param>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.Applicator">
-            <summary>
-            Gets or sets an action that is called by the Apply method to apply this
-            rule to a fake object call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.Actions">
-            <summary>
-            Gets a collection of actions that should be invoked when the configured
-            call is made.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.OutAndRefParametersValues">
-            <summary>
-            Gets or sets values to apply to output and reference variables.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.CallBaseMethod">
-            <summary>
-            Gets or sets a value indicating whether the base method of the fake object call should be
-            called when the fake object call is made.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.NumberOfTimesToCall">
-            <summary>
-            Gets or sets the number of times the configured rule should be used.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.DescriptionOfValidCall">
-            <summary>
-            Gets a description of calls the rule is applicable to.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAnyCallConfigurationWithReturnTypeSpecified`1">
-            <summary>
-            Aggregate of IReturnValueArgumentValidationConfiguration&lt;T&gt; and IWhereConfiguration&lt;IAnyCallConfigurationWithReturnTypeSpecified&lt;T&gt;&gt;.
-            </summary>
-            <typeparam name="T">The type of fake object that is configured.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IReturnValueArgumentValidationConfiguration`1">
-            <summary>
-            Configures a call that returns a value and allows the use to
-            specify validations for arguments.
-            </summary>
-            <typeparam name="TMember">The type of the member.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IReturnValueConfiguration`1">
-            <summary>
-            Configures a call that returns a value.
-            </summary>
-            <typeparam name="TMember">The type of the member.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IExceptionThrowerConfiguration">
-            <summary>
-            Configuration that lets the developer specify that an exception should be
-            thrown by a fake object call.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IHideObjectMembers">
-            <summary>
-            Hides standard Object members to make fluent interfaces
-            easier to read. Found in the source of Autofac: <see cref="!:http://code.google.com/p/autofac/"/>
-            Based on blog post here:
-            <see cref="!:http://www.clariusconsulting.net/blogs/kzu/archive/2008/03/10/58301.aspx"/>
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.ToString">
-            <summary>
-            Hides the ToString-method.
-            </summary>
-            <returns>A string representation of the implementing object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.Equals(System.Object)">
-            <summary>
-            Determines whether the specified <see cref="T:System.Object"/> is equal to this instance.
-            </summary>
-            <param name="o">The <see cref="T:System.Object"/> to compare with this instance.</param>
-            <returns>
-            <c>true</c> if the specified <see cref="T:System.Object"/> is equal to this instance; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.GetHashCode">
-            <summary>
-            Returns a hash code for this instance.
-            </summary>
-            <returns>
-            A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.GetType">
-            <summary>
-            Gets the type.
-            </summary>
-            <returns>The exact runtime type of the current instance.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IExceptionThrowerConfiguration.Throws(System.Func{FakeItEasy.Core.IFakeObjectCall,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="exceptionFactory">A function that creates the exception to throw.</param>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.ICallbackConfiguration`1">
-            <summary>
-            Configuration for callbacks of fake object calls.
-            </summary>
-            <typeparam name="TInterface">The type of interface to return.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.ICallbackConfiguration`1.Invokes(System.Action{FakeItEasy.Core.IFakeObjectCall})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="action">The action to invoke.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAssertConfiguration">
-            <summary>
-            Allows the developer to assert on a call that's configured.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IAssertConfiguration.MustHaveHappened(FakeItEasy.Repeated)">
-            <summary>
-            Asserts that the configured call has happened the number of times
-            constrained by the repeatConstraint parameter.
-            </summary>
-            <param name="repeatConstraint">A constraint for how many times the call
-            must have happened.</param>
-            <exception cref="T:FakeItEasy.ExpectationException">The call has not been called a number of times
-            that passes the repeat constraint.</exception>
-        </member>
-        <member name="T:FakeItEasy.Configuration.ICallBaseConfiguration">
-            <summary>
-            Configuration that lets you specify that a fake object call should call it's base method.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.ICallBaseConfiguration.CallsBaseMethod">
-            <summary>
-            When the configured method or methods are called the call
-            will be delegated to the base method of the faked method.
-            </summary>
-            <returns>A configuration object.</returns>
-            <exception cref="T:System.InvalidOperationException">The fake object is of an abstract type or an interface
-            and no base method exists.</exception>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IReturnValueConfiguration`1.ReturnsLazily(System.Func{FakeItEasy.Core.IFakeObjectCall,`0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IArgumentValidationConfiguration`1">
-            <summary>
-            Provides configurations to validate arguments of a fake object call.
-            </summary>
-            <typeparam name="TInterface">The type of interface to return.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IArgumentValidationConfiguration`1.WhenArgumentsMatch(System.Func{FakeItEasy.ArgumentCollection,System.Boolean})">
-            <summary>
-            Configures the call to be accepted when the specified predicate returns true.
-            </summary>
-            <param name="argumentsPredicate">The argument predicate.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IWhereConfiguration`1">
-            <summary>
-            Provides a way to configure predicates for when a call should be applied.
-            </summary>
-            <typeparam name="T">The type of fake object that is going to be configured..</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IWhereConfiguration`1.Where(System.Func{FakeItEasy.Core.IFakeObjectCall,System.Boolean},System.Action{FakeItEasy.IOutputWriter})">
-            <summary>
-            Applies a predicate to constrain which calls will be considered for interception.
-            </summary>
-            <param name="predicate">A predicate for a fake object call.</param>
-            <param name="descriptionWriter">An action that writes a description of the predicate
-            to the output.</param>
-            <returns>The configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.A`1">
-            <summary>
-            Provides an API entry point for constraining arguments of fake object calls.
-            </summary>
-            <typeparam name="T">The type of argument to validate.</typeparam>
-        </member>
-        <member name="P:FakeItEasy.A`1.That">
-            <summary>
-            Gets an argument constraint object that will be used to constrain a method call argument.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.A`1._">
-            <summary>
-            Gets a constraint that considers any value of an argument as valid.
-            </summary>
-            <remarks>This is a shortcut for the "Ignored"-property.</remarks>
-        </member>
-        <member name="P:FakeItEasy.A`1.Ignored">
-            <summary>
-            Gets a constraint that considers any value of an argument as valid.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.ExceptionMessages">
-            <summary>
-              A strongly-typed resource class, for looking up localized strings, etc.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ResourceManager">
-            <summary>
-              Returns the cached ResourceManager instance used by this class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.Culture">
-            <summary>
-              Overrides the current thread's CurrentUICulture property for all
-              resource lookups using this strongly typed resource class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ApplicatorNotSetExceptionMessage">
-            <summary>
-              Looks up a localized string similar to The Apply method of the ExpressionInterceptor may no be called before the Applicator property has been set..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ArgumentNameDoesNotExist">
-            <summary>
-              Looks up a localized string similar to The specified argument name does not exist in the ArgumentList..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ArgumentsForConstructorOnInterfaceType">
-            <summary>
-              Looks up a localized string similar to Arguments for constructor was specified when generating proxy of interface type..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ArgumentValidationDefaultMessage">
-            <summary>
-              Looks up a localized string similar to An argument validation was not configured correctly..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CalledTooFewTimesMessage">
-            <summary>
-              Looks up a localized string similar to The method &apos;{0}&apos; was called too few times, expected #{1} times but was called #{2} times..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CalledTooManyTimesMessage">
-            <summary>
-              Looks up a localized string similar to The method &apos;{0}&apos; was called too many times, expected #{1} times but was called #{2} times..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CanNotGenerateFakeMessage">
-             <summary>
-               Looks up a localized string similar to Can not create fake of the type &apos;{0}&apos;, it&apos;s not registered in the current container and the current IProxyGenerator can not generate the fake.
-            
-            The following constructors failed:
-            {1}.
-             </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ConfiguringNonFakeObjectExceptionMessage">
-            <summary>
-              Looks up a localized string similar to Error when accessing FakeObject, the specified argument is of the type &apos;{0}&apos; which is not faked..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CreatingExpressionCallMatcherWithNonMethodOrPropertyExpression">
-            <summary>
-              Looks up a localized string similar to An ExpressionCallMatcher can only be created for expressions that represents a method call or a property getter..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FailedToGenerateFakeWithArgumentsForConstructorPattern">
-             <summary>
-               Looks up a localized string similar to 
-            
-              The current proxy generator failed to create a proxy with the specified arguments for the constructor:
-            
-              Reason for failure:
-                - {0}
-              
-            .
-             </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FailedToGenerateProxyPattern">
-             <summary>
-               Looks up a localized string similar to FakeItEasy failed to create fake object of type &quot;{0}&quot;.
-            
-            1. The type is not registered in the current IFakeObjectContainer.
-            2. The current IProxyGenerator failed to generate a proxy for the following reason:
-            
-            {1}.
-             </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FakeCreationExceptionDefaultMessage">
-            <summary>
-              Looks up a localized string similar to Unable to create fake object..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FakingNonAbstractClassWithArgumentsForConstructor">
-            <summary>
-              Looks up a localized string similar to Only abstract classes can be faked using the A.Fake-method that takes an enumerable of objects as arguments for constructor, use the overload that takes an expression instead..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.MemberAccessorNotCorrectExpressionType">
-            <summary>
-              Looks up a localized string similar to The member accessor expression must be a lambda expression with a MethodCallExpression or MemberAccessExpression as its body..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.MemberCanNotBeIntercepted">
-            <summary>
-              Looks up a localized string similar to The specified method can not be configured since it can not be intercepted by the current IProxyGenerator..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.MethodMissmatchWhenPlayingBackRecording">
-            <summary>
-              Looks up a localized string similar to The method of the call did not match the method of the recorded call, the recorded sequence is no longer valid..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NoConstructorMatchingArguments">
-            <summary>
-              Looks up a localized string similar to No constructor matching the specified arguments was found on the type {0}..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NoDefaultConstructorMessage">
-            <summary>
-              Looks up a localized string similar to Can not generate fake object for the class since no usable default constructor was found, specify a constructor call..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NoMoreRecordedCalls">
-            <summary>
-              Looks up a localized string similar to All the recorded calls has been applied, the recorded sequence is no longer valid..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NonConstructorExpressionMessage">
-            <summary>
-              Looks up a localized string similar to Only expression of the type ExpressionType.New (constructor calls) are accepted..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NowCalledDirectly">
-            <summary>
-              Looks up a localized string similar to The Now-method on the event raise is not meant to be called directly, only use it to register to an event on a fake object that you want to be raised..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NumberOfOutAndRefParametersDoesNotMatchCall">
-            <summary>
-              Looks up a localized string similar to The number of values for out and ref parameters specified does not match the number of out and ref parameters in the call..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.OrderedAssertionsAlreadyOpen">
-            <summary>
-              Looks up a localized string similar to A scope for ordered assertions is already opened, close that scope before opening another one..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.SpecifiedCallIsNotToFakedObject">
-            <summary>
-              Looks up a localized string similar to The specified call is not made on a fake object..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.TypeCanNotBeProxied">
-            <summary>
-              Looks up a localized string similar to The current fake proxy generator can not create proxies of the type {0}..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.UnableToCreateDummyPattern">
-            <summary>
-              Looks up a localized string similar to FakeItEasy was unable to create dummy of type &quot;{0}&quot;, register it in the current IFakeObjectContainer to enable this..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.WasCalledWrongNumberOfTimes">
-            <summary>
-              Looks up a localized string similar to Expected to find call {0} the number of times specified by the predicate &apos;{1}&apos; but found it {2} times among the calls:.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.WrongNumberOfArgumentNamesMessage">
-            <summary>
-              Looks up a localized string similar to The number of argument names does not match the number of arguments..
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Raise`1">
-            <summary>
-            A class exposing an event handler to attach to an event of a faked object
-            in order to raise that event.
-            </summary>
-            <typeparam name="TEventArgs">The type of the event args.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Core.IEventRaiserArguments">
-            <summary>
-            Used by the event raising rule of fake objects to get the event arguments used in
-            a call to Raise.With.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IEventRaiserArguments.Sender">
-            <summary>
-            Gets the sender of the event.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IEventRaiserArguments.EventArguments">
-            <summary>
-            Gets the event arguments of the event.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Raise`1.Now(System.Object,`0)">
-            <summary>
-            Register this event handler to an event on a faked object in order to raise that event.
-            </summary>
-            <param name="sender">The sender of the event.</param>
-            <param name="e">Event args for the event.</param>
-        </member>
-        <member name="P:FakeItEasy.Raise`1.Go">
-            <summary>
-            Gets a generic event handler to attach to the event to raise.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Fake`1">
-            <summary>
-            Represents a fake object that provides an API for configuring a faked object, exposed by the
-            FakedObject-property.
-            </summary>
-            <typeparam name="T">The type of the faked object.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IStartConfiguration`1">
-            <summary>
-            Provides methods for configuring a fake object.
-            </summary>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfiguration`1.CallsTo``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <typeparam name="TMember">The type of the return value of the member.</typeparam>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfiguration`1.CallsTo(System.Linq.Expressions.Expression{System.Action{`0}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfiguration`1.AnyCall">
-            <summary>
-            Configures the behavior of the fake object when a call is made to any method on the
-            object.
-            </summary>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Fake`1"/> class. 
-            Creates a new fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.#ctor(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{`0}})">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Fake`1"/> class. 
-            Creates a new fake object using the specified options.
-            </summary>
-            <param name="options">
-            Options used to create the fake object.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.CallsTo(System.Linq.Expressions.Expression{System.Action{`0}})">
-            <summary>
-            Configures calls to the specified member.
-            </summary>
-            <param name="callSpecification">An expression specifying the call to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.CallsTo``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-            Configures calls to the specified member.
-            </summary>
-            <typeparam name="TMember">The type of value the member returns.</typeparam>
-            <param name="callSpecification">An expression specifying the call to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.AnyCall">
-            <summary>
-            Configures any call to the fake object.
-            </summary>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="P:FakeItEasy.Fake`1.FakedObject">
-            <summary>
-            Gets the faked object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Fake`1.RecordedCalls">
-            <summary>
-            Gets all calls made to the faked object.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ApplicationDirectoryAssembliesTypeCatalogue">
-            <summary>
-            Access all types in all assemblies in the same directory as the FakeItEasy assembly.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ITypeCatalogue">
-            <summary>
-            Provides a set of types that are available.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ITypeCatalogue.GetAvailableTypes">
-            <summary>
-            Gets a collection of available types.
-            </summary>
-            <returns>The available types.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.ApplicationDirectoryAssembliesTypeCatalogue.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.ApplicationDirectoryAssembliesTypeCatalogue"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ApplicationDirectoryAssembliesTypeCatalogue.GetAvailableTypes">
-            <summary>
-            Gets a collection of available types.
-            </summary>
-            <returns>The available types.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAnyCallConfigurationWithNoReturnTypeSpecified">
-            <summary>
-            Configuration for any call to a faked object.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IVoidArgumentValidationConfiguration">
-            <summary>
-            Provides configuration methods for methods that does not have a return value and
-            allows the use to specify validations for arguments.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IVoidConfiguration">
-            <summary>
-            Provides configuration methods for methods that does not have a return value.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IOutAndRefParametersConfiguration">
-            <summary>
-            Lets the developer configure output values of out and ref parameters.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IOutAndRefParametersConfiguration.AssignsOutAndRefParameters(System.Object[])">
-            <summary>
-            Specifies output values for out and ref parameters. Specify the values in the order
-            the ref and out parameters has in the configured call, any non out and ref parameters are ignored.
-            </summary>
-            <param name="values">The values.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IVoidConfiguration.DoesNothing">
-            <summary>
-            Configures the specified call to do nothing when called.
-            </summary>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IAnyCallConfigurationWithNoReturnTypeSpecified.WithReturnType``1">
-            <summary>
-            Matches calls that has the return type specified in the generic type parameter.
-            </summary>
-            <typeparam name="TMember">The return type of the members to configure.</typeparam>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.IoC.Module">
-            <summary>
-            Manages registration of a set of components in a DictionaryContainer.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IoC.Module.RegisterDependencies(FakeItEasy.IoC.DictionaryContainer)">
-            <summary>
-            Registers the components of this module.
-            </summary>
-            <param name="container">The container to register components in.</param>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRecordingCallRuleFactory">
-            <summary>
-            A factory that creates instances of the RecordingCallRuleType.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IRecordingCallRuleFactory.Create``1(FakeItEasy.Core.FakeManager,FakeItEasy.Configuration.RecordedCallRule)">
-            <summary>
-            Creates the specified fake object.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-            <param name="fakeObject">The fake object the rule belongs to.</param>
-            <param name="recordedRule">The rule that's being recorded.</param>
-            <returns>A RecordingCallRule instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IStartConfigurationFactory">
-            <summary>
-            A factory responsible for creating start configuration for fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfigurationFactory.CreateConfiguration``1(FakeItEasy.Core.FakeManager)">
-            <summary>
-            Creates a start configuration for the specified fake object that fakes the
-            specified type.
-            </summary>
-            <typeparam name="TFake">The type of the fake object.</typeparam>
-            <param name="fakeObject">The fake object to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.FakeConfigurationException">
-            <summary>
-            An exception that can be thrown when something goes wrong with the configuration
-            of a fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
-            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
-            <exception cref="T:System.ArgumentNullException">
-            The <paramref name="info"/> parameter is null.
-            </exception>
-            <exception cref="T:System.Runtime.Serialization.SerializationException">
-            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
-            </exception>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IFakeConfigurationManager">
-            <summary>
-            Handles the configuration of fake object given an expression specifying
-            a call on a faked object.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAfterCallSpecifiedConfiguration">
-            <summary>
-            Lets you set up expectations and configure repeat for the configured call.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRepeatConfiguration">
-            <summary>
-            Provides configuration for method calls that has a return value.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IRepeatConfiguration.NumberOfTimes(System.Int32)">
-            <summary>
-            Specifies the number of times for the configured event.
-            </summary>
-            <param name="numberOfTimesToRepeat">The number of times to repeat.</param>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAfterCallSpecifiedWithOutAndRefParametersConfiguration">
-            <summary>
-            A combination of the IAfterCallSpecifiedConfiguration and IOutAndRefParametersConfiguration
-            interfaces.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRecordingConfiguration">
-            <summary>
-            Configurations for when a configured call is recorded.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRecordingConfigurationWithArgumentValidation">
-            <summary>
-            Provides configuration from VisualBasic.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.RecordedCallRule">
-            <summary>
-            A call rule that has been recorded.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.RecordingCallRule`1">
-            <summary>
-            A call rule that "sits and waits" for the next call, when
-            that call occurs the recorded rule is added for that call.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Core.ICallCollectionAndCallMatcherAccessor">
-            <summary>
-            Provides access to a set of calls and a call matcher for these calls.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ICallMatcherAccessor">
-            <summary>
-            Provides access to a call matcher.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ICallMatcherAccessor.Matcher">
-            <summary>
-            Gets a call predicate that can be used to check if a fake object call matches
-            the specified constraint.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ICallCollectionAndCallMatcherAccessor.Calls">
-            <summary>
-            Gets the set of calls.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.RuleBuilder.Factory">
-            <summary>
-            Represents a delegate that creates a configuration object from
-            a fake object and the rule to build.
-            </summary>
-            <param name="ruleBeingBuilt">The rule that's being built.</param>
-            <param name="fakeObject">The fake object the rule is for.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.ICallMatcher">
-            <summary>
-            Represents a predicate that matches a fake object call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ICallMatcher.Matches(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets a value indicating whether the call matches the predicate.
-            </summary>
-            <param name="fakeObjectCall">The call to match.</param>
-            <returns>True if the call matches the predicate.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.ArgumentInfo">
-            <summary>
-            Represents an argument and a dummy value to use for that argument.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ArgumentInfo.#ctor(System.Boolean,System.Type,System.Object)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.ArgumentInfo"/> class.
-            </summary>
-            <param name="wasSuccessfullyResolved">A value indicating if the dummy value was successfully resolved.</param>
-            <param name="typeOfArgument">The type of argument.</param>
-            <param name="resolvedValue">The resolved value.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.ArgumentInfo.WasSuccessfullyResolved">
-            <summary>
-            Gets a value indicating whether a dummy argument value was successfully
-            resolved.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ArgumentInfo.TypeOfArgument">
-            <summary>
-            Gets the type of the argument.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ArgumentInfo.ResolvedValue">
-            <summary>
-            Gets the resolved value.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ArgumentValueFormatter.RangedFormatter">
-            <summary>
-            Holds a formatter as well as the distance between a type to be formatted
-            and the type for which the formatted is registered.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.CallInterceptedEventArgs">
-            <summary>
-            Represents an event that happens when a call has been intercepted by a proxy.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.CallInterceptedEventArgs.#ctor(FakeItEasy.Core.IWritableFakeObjectCall)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.CallInterceptedEventArgs"/> class.
-            </summary>
-            <param name="call">The call.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.CallInterceptedEventArgs.Call">
-            <summary>
-            Gets the call that was intercepted.
-            </summary>
-            <value>The call.</value>
-        </member>
-        <member name="T:FakeItEasy.Core.CallRuleMetadata">
-            <summary>
-            Keeps track of metadata for interceptions.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.CallRuleMetadata.HasNotBeenCalledSpecifiedNumberOfTimes">
-            <summary>
-            Gets whether the rule has been called the number of times specified or not.
-            </summary>
-            <returns>True if the rule has not been called the number of times specified.</returns>
-        </member>
-        <member name="P:FakeItEasy.Core.CallRuleMetadata.CalledNumberOfTimes">
-            <summary>
-            Gets or sets the number of times the rule has been used.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.CallRuleMetadata.Rule">
-            <summary>
-            Gets or sets the rule this metadata object is tracking.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.IArgumentConstraintManager`1">
-            <summary>
-            Manages attaching of argument constraints.
-            </summary>
-            <typeparam name="T">The type of argument to constrain.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.IArgumentConstraintManager`1.Matches(System.Func{`0,System.Boolean},System.Action{FakeItEasy.IOutputWriter})">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="predicate">The predicate that should constrain the argument.</param>
-            <param name="descriptionWriter">An action that will be write a description of the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="P:FakeItEasy.IArgumentConstraintManager`1.Not">
-            <summary>
-            Inverts the logic of the matches method.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IArgumentConstraint">
-            <summary>
-            Validates an argument, checks that it's valid in a specific fake call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IArgumentConstraint.WriteDescription(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a description of the argument constraint to the specified writer.
-            </summary>
-            <param name="writer">
-            The writer.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Core.IArgumentConstraint.IsValid(System.Object)">
-            <summary>
-            Gets whether the argument is valid.
-            </summary>
-            <param name="argument">The argument to validate.</param>
-            <returns>True if the argument is valid.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.DefaultFakeManagerAccessor">
-            <summary>
-            Default implementation of <see cref="T:FakeItEasy.Core.IFakeManagerAccessor"/>.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeManagerAccessor">
-            <summary>
-            Attaches a fake manager to the proxy so that intercepted
-            calls can be configured.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeManagerAccessor.AttachFakeManagerToProxy(System.Type,System.Object,FakeItEasy.Creation.ICallInterceptedEventRaiser)">
-            <summary>
-            Attaches a <see cref="T:FakeItEasy.Core.FakeManager"/> to the specified proxy, listening to
-            the event raiser.
-            </summary>
-            <param name="typeOfFake">The type of the fake object proxy.</param>
-            <param name="proxy">The proxy to attach to.</param>
-            <param name="eventRaiser">The event raiser to listen to.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeManagerAccessor.GetFakeManager(System.Object)">
-            <summary>
-            Gets the fake manager associated with the proxy.
-            </summary>
-            <param name="proxy">The proxy to get the manager from.</param>
-            <returns>A fake manager.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeManagerAccessor.AttachFakeManagerToProxy(System.Type,System.Object,FakeItEasy.Creation.ICallInterceptedEventRaiser)">
-            <summary>
-            Attaches a <see cref="T:FakeItEasy.Core.FakeManager"/> to the specified proxy, listening to
-            the event raiser.
-            </summary>
-            <param name="typeOfFake">The type of the fake object proxy.</param>
-            <param name="proxy">The proxy to attach to.</param>
-            <param name="eventRaiser">The event raiser to listen to.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeManagerAccessor.GetFakeManager(System.Object)">
-            <summary>
-            Gets the fake manager associated with the proxy.
-            </summary>
-            <param name="proxy">The proxy to get the manager from.</param>
-            <returns>A fake manager.</returns>
-        </member>
-        <member name="T:FakeItEasy.Creation.ITaggable">
-            <summary>
-            Represents an object that can be tagged with another object. When implemented
-            by a proxy returned from an <see cref="T:FakeItEasy.Creation.IProxyGenerator"/> FakeItEasy uses the tag
-            to store a reference to the <see cref="T:FakeItEasy.Core.FakeManager"/> that handles that proxy.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ITaggable.Tag">
-            <summary>
-            Gets or sets the tag.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.DefaultFakeObjectCallFormatter">
-            <summary>
-            The default implementation of the IFakeObjectCallFormatter interface.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCallFormatter">
-            <summary>
-            Provides string formatting for fake object calls.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallFormatter.GetDescription(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets a human readable description of the specified
-            fake object call.
-            </summary>
-            <param name="call">The call to get a description for.</param>
-            <returns>A description of the call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeObjectCallFormatter.GetDescription(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets a human readable description of the specified
-            fake object call.
-            </summary>
-            <param name="call">The call to get a description for.</param>
-            <returns>A description of the call.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.DefaultFakeWrapperConfigurer">
-            <summary>
-            Handles configuring of fake objects to delegate all their calls to a wrapped instance.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeWrapperConfigurer">
-            <summary>
-            Manages configuration of fake objects to wrap instances.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeWrapperConfigurer.ConfigureFakeToWrap(System.Object,System.Object,FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Configures the specified faked object to wrap the specified instance.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <param name="wrappedInstance">The instance to wrap.</param>
-            <param name="recorder">The recorder to use, null if no recording should be made.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeWrapperConfigurer.ConfigureFakeToWrap(System.Object,System.Object,FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Configures the specified faked object to wrap the specified instance.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <param name="wrappedInstance">The instance to wrap.</param>
-            <param name="recorder">The recorder to use, null if no recording should be made.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.DelegateFakeObjectContainer">
-            <summary>
-            A fake object container where delegates can be registered that are used to
-            resolve fake objects.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectContainer">
-            <summary>
-            A container that can create fake objects.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectConfigurator">
-            <summary>
-            Handles global configuration of fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectConfigurator.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Applies base configuration to a fake object.
-            </summary>
-            <param name="typeOfFake">The type the fake object represents.</param>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Creates a dummy object of the specified type using the specified arguments if it's
-            supported by the container, returns a value indicating if it's supported or not.
-            </summary>
-            <param name="typeOfDummy">The type of dummy object to create.</param>
-            <param name="fakeObject">The dummy object that was created if the method returns true.</param>
-            <returns>True if a dummy object can be created.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.DelegateFakeObjectContainer"/> class. 
-            Creates a new instance of the DelegateFakeObjectContainer.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Creates a fake object of the specified type using the specified arguments if it's
-            supported by the container, returns a value indicating if it's supported or not.
-            </summary>
-            <param name="typeOfDummy">The type of dummy object to create.</param>
-            <param name="fakeObject">The fake object that was created if the method returns true.</param>
-            <returns>True if a fake object can be created.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Configures the fake.
-            </summary>
-            <param name="typeOfFake">The type of fake.</param>
-            <param name="fakeObject">The fake object.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.Register``1(System.Func{``0})">
-            <summary>
-            Registers the specified fake delegate.
-            </summary>
-            <typeparam name="T">The type of the return value of the method that <paramref name="fakeDelegate"/> encapsulates.</typeparam>
-            <param name="fakeDelegate">The fake delegate.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.DynamicContainer">
-            <summary>
-            A IFakeObjectContainer implementation that uses MEF to load IFakeDefinitions and
-            IFakeConfigurations.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.DynamicContainer.#ctor(System.Collections.Generic.IEnumerable{FakeItEasy.IDummyDefinition},System.Collections.Generic.IEnumerable{FakeItEasy.IFakeConfigurator})">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.DynamicContainer"/> class.
-            </summary>
-            <param name="dummyDefinitions">The dummy definitions.</param>
-            <param name="fakeConfigurators">The fake configurators.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DynamicContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Creates a fake object of the specified type using the specified arguments if it's
-            supported by the container, returns a value indicating if it's supported or not.
-            </summary>
-            <param name="typeOfDummy">The type of fake object to create.</param>
-            <param name="fakeObject">The fake object that was created if the method returns true.</param>
-            <returns>True if a fake object can be created.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DynamicContainer.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Applies base configuration to a fake object.
-            </summary>
-            <param name="typeOfFake">The type the fake object represents.</param>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeCreationException">
-            <summary>
-            An exception that is thrown when there was an error creating a fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
-            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
-            <exception cref="T:System.ArgumentNullException">
-            The <paramref name="info"/> parameter is null.
-            </exception>
-            <exception cref="T:System.Runtime.Serialization.SerializationException">
-            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
-            </exception>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeManager">
-            <content>Auto fake property rule.</content>
-            <summary>
-            The central point in the API for proxied fake objects handles interception
-            of fake object calls by using a set of rules. User defined rules can be inserted
-            by using the AddRule-method.
-            </summary>
-            <content>Event rule.</content>
-            <content>Object member rule.</content>
-            <content>Property behavior rule.</content>
-            <content>Property setter rule.</content>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeManager"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.AddRuleFirst(FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Adds a call rule to the fake object.
-            </summary>
-            <param name="rule">The rule to add.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.AddRuleLast(FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Adds a call rule last in the list of user rules, meaning it has the lowest priority possible.
-            </summary>
-            <param name="rule">The rule to add.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.RemoveRule(FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Removes the specified rule for the fake object.
-            </summary>
-            <param name="rule">The rule to remove.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.AddInterceptionListener(FakeItEasy.Core.IInterceptionListener)">
-            <summary>
-            Adds an interception listener to the manager.
-            </summary>
-            <param name="listener">The listener to add.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.ClearUserRules">
-            <summary>
-            Removes any specified user rules.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.Object">
-            <summary>
-            Gets the faked object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.FakeObjectType">
-            <summary>
-            Gets the faked type.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.Rules">
-            <summary>
-            Gets the interceptions that are currently registered with the fake object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.RecordedCallsInScope">
-            <summary>
-            Gets a collection of all the calls made to the fake object within the current scope.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeManager.Factory">
-            <summary>
-            A delegate responsible for creating FakeObject instances.
-            </summary>
-            <returns>An instance of <see cref="T:FakeItEasy.Core.FakeManager"/>.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.IInterceptedFakeObjectCall">
-            <summary>
-            Represents a call to a fake object at interception time.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IWritableFakeObjectCall">
-            <summary>
-            Represents a fake object call that can be edited.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCall">
-            <summary>
-            Represents a call to a fake object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCall.Method">
-            <summary>
-            Gets the method that's called.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCall.Arguments">
-            <summary>
-            Gets the arguments used in the call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCall.FakedObject">
-            <summary>
-            Gets the faked object the call is performed on.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.SetReturnValue(System.Object)">
-            <summary>
-            Sets the return value of the call.
-            </summary>
-            <param name="value">The return value to set.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.CallBaseMethod">
-            <summary>
-            Calls the base method of the faked type.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.SetArgumentValue(System.Int32,System.Object)">
-            <summary>
-            Sets the value of the argument at the specified index in the parameters list.
-            </summary>
-            <param name="index">The index of the argument to set the value of.</param>
-            <param name="value">The value to set to the argument.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.AsReadOnly">
-            <summary>
-            Freezes the call so that it can no longer be modified.
-            </summary>
-            <returns>A completed fake object call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.IInterceptedFakeObjectCall.DoNotRecordCall">
-            <summary>
-            Sets that the call should not be recorded by the fake manager.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeScope">
-            <summary>
-            Represents a scope for fake objects, calls configured within a scope
-            are only valid within that scope. Only calls made within a scope
-            are accessible from within a scope so for example asserts will only
-            assert on those calls done within the scope.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeScope">
-            <summary>
-            Provides access to all calls made to fake objects within a scope.
-            Scopes calls so that only calls made within the scope are visible.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.Create">
-            <summary>
-            Creates a new scope and sets it as the current scope.
-            </summary>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.Create(FakeItEasy.Core.IFakeObjectContainer)">
-            <summary>
-            Creates a new scope and sets it as the current scope, using the specified
-            container as the container for the new scope.
-            </summary>
-            <param name="container">The container to use for the new scope.</param>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.Dispose">
-            <summary>
-            Closes the scope.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.AddInterceptedCall(FakeItEasy.Core.FakeManager,FakeItEasy.Core.ICompletedFakeObjectCall)">
-            <summary>
-            Adds an intercepted call to the current scope.
-            </summary>
-            <param name="fakeManager">The fake object.</param>
-            <param name="call">The call that is intercepted.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.AddRuleFirst(FakeItEasy.Core.FakeManager,FakeItEasy.Core.CallRuleMetadata)">
-            <summary>
-            Adds a fake object call to the current scope.
-            </summary>
-            <param name="fakeManager">The fake object.</param>
-            <param name="rule">The rule to add.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.IInterceptionListener">
-            <summary>
-            Represents a listener for fake object calls, can be plugged into a
-            FakeManager instance to listen to all intercepted calls.
-            </summary>
-            <remarks>The OnBeforeCallIntercepted method will be invoked before the OnBeforeCallIntercepted method of any
-            previously added listener. The OnAfterCallIntercepted method will be invoked after the OnAfterCallIntercepted
-            method of any previously added listener.</remarks>
-        </member>
-        <member name="M:FakeItEasy.Core.IInterceptionListener.OnBeforeCallIntercepted(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Called when the interception begins but before any call rules
-            has been applied.
-            </summary>
-            <param name="interceptedCall">The intercepted call.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IInterceptionListener.OnAfterCallIntercepted(FakeItEasy.Core.ICompletedFakeObjectCall,FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Called when the interception has been completed and rules has been
-            applied.
-            </summary>
-            <param name="interceptedCall">The intercepted call.</param>
-            <param name="ruleThatWasApplied">The rule that was applied to the call.</param>
-        </member>
-        <member name="T:FakeItEasy.Creation.IProxyGenerator">
-            <summary>
-            An interface to be implemented by classes that can generate proxies for FakeItEasy.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.IProxyGenerator.GenerateProxy(System.Type,System.Collections.Generic.IEnumerable{System.Type},System.Collections.Generic.IEnumerable{System.Object},System.Collections.Generic.IEnumerable{System.Reflection.Emit.CustomAttributeBuilder})">
-            <summary>
-            Generates a proxy of the specified type and returns a result object containing information
-            about the success of the generation and the proxy if it was generated.
-            </summary>
-            <param name="typeOfProxy">The type of proxy to generate.</param>
-            <param name="additionalInterfacesToImplement">Interfaces to be implemented by the proxy.</param>
-            <param name="argumentsForConstructor">Arguments to pass to the constructor of the type in <paramref name="typeOfProxy" />.</param>
-            <param name="customAttributeBuilders">The custom attribute builders.</param>
-            <returns>A result containing the generated proxy.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IProxyGenerator.GenerateProxy(System.Type,System.Collections.Generic.IEnumerable{System.Type},System.Collections.Generic.IEnumerable{System.Object})">
-            <summary>
-            Generates a proxy of the specified type and returns a result object containing information
-            about the success of the generation and the proxy if it was generated.
-            </summary>
-            <param name="typeOfProxy">The type of proxy to generate.</param>
-            <param name="additionalInterfacesToImplement">Interfaces to be implemented by the proxy.</param>
-            <param name="argumentsForConstructor">Arguments to pass to the constructor of the type in <paramref name="typeOfProxy" />.</param>
-            <returns>A result containing the generated proxy.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IProxyGenerator.MethodCanBeInterceptedOnInstance(System.Reflection.MethodInfo,System.Object,System.String@)">
-            <summary>
-            Gets a value indicating whether the specified member can be intercepted by the proxy generator.
-            </summary>
-            <param name="method">The member to test.</param>
-            <param name="callTarget">The instance the method will be called on.</param>
-            <param name="failReason">The reason the method can not be intercepted.</param>
-            <returns>True if the member can be intercepted.</returns>
-        </member>
-        <member name="T:FakeItEasy.Creation.ICallInterceptedEventRaiser">
-            <summary>
-            An object that raises an event every time a call to a proxy has been intercepted.
-            </summary>
-        </member>
-        <member name="E:FakeItEasy.Creation.ICallInterceptedEventRaiser.CallWasIntercepted">
-            <summary>
-            Raised when a call is intercepted.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ICompletedFakeObjectCall">
-            <summary>
-            Represents a completed call to a fake object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ICompletedFakeObjectCall.ReturnValue">
-            <summary>
-            Gets the value set to be returned from the call.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.IOutputWriter">
-            <summary>
-            Represents a text writer that writes to the output.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IOutputWriter.Write(System.String)">
-            <summary>
-            Writes the specified value to the output.
-            </summary>
-            <param name="value">The value to write.</param>
-            <returns>The writer for method chaining.</returns>
-        </member>
-        <member name="M:FakeItEasy.IOutputWriter.WriteArgumentValue(System.Object)">
-            <summary>
-            Formats the specified argument value as a string and writes
-            it to the output.
-            </summary>
-            <param name="value">The value to write.</param>
-            <returns>The writer for method chaining.</returns>
-        </member>
-        <member name="M:FakeItEasy.IOutputWriter.Indent">
-            <summary>
-            Indents the writer.
-            </summary>
-            <returns>A disposable that will unindent the writer when disposed.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.TypeCatalogueInstanceProvider">
-            <summary>
-            Provides instances from type catalogues.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.TypeCatalogueInstanceProvider.InstantiateAllOfType``1">
-            <summary>
-            Gets an instance per type in the catalogue that is a descendant
-            of the specified type.
-            </summary>
-            <typeparam name="T">The type of instances to get.</typeparam>
-            <returns>A sequence of instances of the specified type.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.MethodInfoManager">
-            <summary>
-            Handles comparisons of instances of <see cref="T:System.Reflection.MethodInfo"/>.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.MethodInfoManager.WillInvokeSameMethodOnTarget(System.Type,System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
-            <summary>
-            Gets a value indicating whether the two instances of <see cref="T:System.Reflection.MethodInfo"/> would invoke the same method
-            if invoked on an instance of the target type.
-            </summary>
-            <param name="target">The type of target for invocation.</param>
-            <param name="first">The first <see cref="T:System.Reflection.MethodInfo"/>.</param>
-            <param name="second">The second <see cref="T:System.Reflection.MethodInfo"/>.</param>
-            <returns>True if the same method would be invoked.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.NullFakeObjectContainer">
-            <summary>
-            A null implementation for the IFakeObjectContainer interface.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.NullFakeObjectContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Always returns false and sets the fakeObject to null.
-            </summary>
-            <param name="typeOfDummy">The type of dummy object to create.</param>
-            <param name="fakeObject">Output variable for the fake object that will always be set to null.</param>
-            <returns>Always return false.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.NullFakeObjectContainer.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Applies base configuration to a fake object.
-            </summary>
-            <param name="typeOfFake">The type the fake object represents.</param>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.WrappedObjectRule">
-            <summary>
-            A call rule that applies to any call and just delegates the
-            call to the wrapped object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.WrappedObjectRule.#ctor(System.Object)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.WrappedObjectRule"/> class. 
-            Creates a new instance.
-            </summary>
-            <param name="wrappedInstance">
-            The object to wrap.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Core.WrappedObjectRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets whether this interceptor is applicable to the specified
-            call, if true is returned the Apply-method of the interceptor will
-            be called.
-            </summary>
-            <param name="fakeObjectCall">The call to check for applicability.</param>
-            <returns>True if the interceptor is applicable.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.WrappedObjectRule.Apply(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies an action to the call, might set a return value or throw
-            an exception.
-            </summary>
-            <param name="fakeObjectCall">The call to apply the interceptor to.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.WrappedObjectRule.NumberOfTimesToCall">
-            <summary>
-            Gets the number of times this call rule is valid, if it's set
-            to null its infinitely valid.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter">
-            <summary>
-            An adapter that adapts an <see cref="T:Castle.DynamicProxy.IInvocation"/> to a <see cref="T:FakeItEasy.Core.IFakeObjectCall"/>.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.#ctor(Castle.DynamicProxy.IInvocation)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter"/> class.
-            </summary>
-            <param name="invocation">The invocation.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.AsReadOnly">
-            <summary>
-            Freezes the call so that it can no longer be modified.
-            </summary>
-            <returns>A completed fake object call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.CallBaseMethod">
-            <summary>
-            Calls the base method, should not be used with interface types.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.SetArgumentValue(System.Int32,System.Object)">
-            <summary>
-            Sets the specified value to the argument at the specified index.
-            </summary>
-            <param name="index">The index of the argument to set the value to.</param>
-            <param name="value">The value to set to the argument.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.SetReturnValue(System.Object)">
-            <summary>
-            Sets the return value of the call.
-            </summary>
-            <param name="returnValue">The return value.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.ToString">
-            <summary>
-            Returns a description of the call.
-            </summary>
-            <returns>
-            A <see cref="T:System.String"/> that represents this instance.
-            </returns>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.Description">
-            <summary>
-            Gets a human readable description of the call.
-            </summary>
-            <value></value>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.ReturnValue">
-            <summary>
-            Gets the value set to be returned from the call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.Method">
-            <summary>
-            Gets the method that's called.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.Arguments">
-            <summary>
-            Gets the arguments used in the call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.FakedObject">
-            <summary>
-            Gets the faked object the call is performed on.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources">
-            <summary>
-              A strongly-typed resource class, for looking up localized strings, etc.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ResourceManager">
-            <summary>
-              Returns the cached ResourceManager instance used by this class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.Culture">
-            <summary>
-              Overrides the current thread's CurrentUICulture property for all
-              resource lookups using this strongly typed resource class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ArgumentsForConstructorDoesNotMatchAnyConstructorMessage">
-            <summary>
-              Looks up a localized string similar to No constructor matches the passed arguments for constructor..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ArgumentsForConstructorOnInterfaceTypeMessage">
-            <summary>
-              Looks up a localized string similar to Arguments for constructor specified for interface type..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ProxyIsSealedTypeMessage">
-            <summary>
-              Looks up a localized string similar to The type of proxy &quot;{0}&quot; is sealed..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ProxyIsValueTypeMessage">
-            <summary>
-              Looks up a localized string similar to The type of proxy must be an interface or a class but it was {0}..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ProxyTypeWithNoDefaultConstructorMessage">
-            <summary>
-              Looks up a localized string similar to No usable default constructor was found on the type {0}..
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.DefaultFakeAndDummyManager">
-            <summary>
-            The default implementation of the IFakeAndDummyManager interface.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeAndDummyManager">
-            <summary>
-            Handles the creation of fake and dummy objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.CreateDummy(System.Type)">
-            <summary>
-            Creates a dummy of the specified type.
-            </summary>
-            <param name="typeOfDummy">The type of dummy to create.</param>
-            <returns>The created dummy.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">The current IProxyGenerator is not able to generate a fake of the specified type and
-            the current IFakeObjectContainer does not contain the specified type.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.CreateFake(System.Type,FakeItEasy.Creation.FakeOptions)">
-            <summary>
-            Creates a fake object of the specified type.
-            </summary>
-            <param name="typeOfFake">The type of fake object to generate.</param>
-            <param name="options">Options for building the fake object.</param>
-            <returns>A fake object.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">The current IProxyGenerator is not able to generate a fake of the specified type.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.TryCreateDummy(System.Type,System.Object@)">
-            <summary>
-            Tries to create a dummy of the specified type.
-            </summary>
-            <param name="typeOfDummy">The type of dummy to create.</param>
-            <param name="result">Outputs the result dummy when creation is successful.</param>
-            <returns>A value indicating whether the creation was successful.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.TryCreateFake(System.Type,FakeItEasy.Creation.FakeOptions,System.Object@)">
-            <summary>
-            Tries to create a fake object of the specified type.
-            </summary>
-            <param name="typeOfFake">The type of fake to create.</param>
-            <param name="options">Options for the creation of the fake.</param>
-            <param name="result">The created fake object when creation is successful.</param>
-            <returns>A value indicating whether the creation was successful.</returns>
-        </member>
-        <member name="T:FakeItEasy.Creation.DefaultFakeCreatorFacade">
-            <summary>
-            Default implementation of the IFakeCreator-interface.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeCreatorFacade">
-            <summary>
-            A facade used by the public API for testability.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeCreatorFacade.CreateFake``1(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{``0}})">
-            <summary>
-            Creates a fake object of the specified type.
-            </summary>
-            <typeparam name="T">The type of fake to create.</typeparam>
-            <param name="options">Options for the created fake object.</param>
-            <returns>The created fake object.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeCreatorFacade.CreateDummy``1">
-            <summary>
-            Creates a dummy object, this can be a fake object or an object resolved
-            from the current IFakeObjectContainer.
-            </summary>
-            <typeparam name="T">The type of dummy to create.</typeparam>
-            <returns>The created dummy.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration and
-            no dummy was registered in the container for the specified type..</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeCreatorFacade.CollectionOfFake``1(System.Int32)">
-            <summary>
-            Creates a collection of fakes of the specified type.
-            </summary>
-            <typeparam name="T">The type of fakes to create.</typeparam>
-            <param name="numberOfFakes">The number of fakes in the collection.</param>
-            <returns>A collection of fake objects of the specified type.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.#ctor(FakeItEasy.Creation.IFakeAndDummyManager)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.DefaultFakeCreatorFacade"/> class.
-            </summary>
-            <param name="fakeAndDummyManager">The fake and dummy manager.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.CreateFake``1(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{``0}})">
-            <summary>
-            Creates a fake object of the specified type.
-            </summary>
-            <typeparam name="T">The type of fake to create.</typeparam>
-            <param name="options">Options for the created fake object.</param>
-            <returns>The created fake object.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.CollectionOfFake``1(System.Int32)">
-            <summary>
-            Creates a collection of fakes of the specified type.
-            </summary>
-            <typeparam name="T">The type of fakes to create.</typeparam>
-            <param name="numberOfFakes">The number of fakes in the collection.</param>
-            <returns>
-            A collection of fake objects of the specified type.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.CreateDummy``1">
-            <summary>
-            Creates a dummy object, this can be a fake object or an object resolved
-            from the current IFakeObjectContainer.
-            </summary>
-            <typeparam name="T">The type of dummy to create.</typeparam>
-            <returns>The created dummy.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration and
-            no dummy was registered in the container for the specified type..</exception>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeOptionsBuilderForWrappers`1">
-            <summary>
-            Provides options for fake wrappers.
-            </summary>
-            <typeparam name="T">The type of the fake object generated.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeOptionsBuilder`1">
-            <summary>
-            Provides options for generating fake object.
-            </summary>
-            <typeparam name="T">The type of fake object generated.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.WithArgumentsForConstructor(System.Collections.Generic.IEnumerable{System.Object})">
-            <summary>
-            Specifies arguments for the constructor of the faked class.
-            </summary>
-            <param name="argumentsForConstructor">The arguments to pass to the constructor of the faked class.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.WithArgumentsForConstructor(System.Linq.Expressions.Expression{System.Func{`0}})">
-            <summary>
-            Specifies arguments for the constructor of the faked class by giving an expression with the call to
-            the desired constructor using the arguments to be passed to the constructor.
-            </summary>
-            <param name="constructorCall">The constructor call to use when creating a class proxy.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.Wrapping(`0)">
-            <summary>
-            Specifies that the fake should delegate calls to the specified instance.
-            </summary>
-            <param name="wrappedInstance">The object to delegate calls to.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.WithAdditionalAttributes(System.Collections.Generic.IEnumerable{System.Reflection.Emit.CustomAttributeBuilder})">
-            <summary>
-            Specifies that the fake should be created with these additional attributes.
-            </summary>
-            <param name="customAttributeBuilders">The attributes to build into the proxy.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.Implements(System.Type)">
-            <summary>
-            Sets up the fake to implement the specified interface in addition to the
-            originally faked class.
-            </summary>
-            <param name="interfaceType">The type of interface to implement.</param>
-            <returns>Options object.</returns>
-            <exception cref="T:System.ArgumentException">The specified type is not an interface.</exception>
-            <exception cref="T:System.ArgumentNullException">The specified type is null.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.OnFakeCreated(System.Action{`0})">
-            <summary>
-            Specifies an action that should be run over the fake object
-            once it's created.
-            </summary>
-            <param name="action">An action to perform.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilderForWrappers`1.RecordedBy(FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Specifies a fake recorder to use.
-            </summary>
-            <param name="recorder">The recorder to use.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.DummyValueCreationSession.#ctor(FakeItEasy.Core.IFakeObjectContainer,FakeItEasy.Creation.IFakeObjectCreator)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.DummyValueCreationSession"/> class.
-            </summary>
-            <param name="container">The container.</param>
-            <param name="fakeObjectCreator">The fake object creator.</param>
-        </member>
-        <member name="T:FakeItEasy.Creation.ProxyGeneratorResult">
-            <summary>
-            Contains the result of a call to TryCreateProxy of IProxyGenerator.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.ProxyGeneratorResult.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.ProxyGeneratorResult"/> class. 
-            Creates a new instance representing a failed proxy
-            generation attempt.
-            </summary>
-            <param name="reasonForFailure">
-            The reason the proxy generation failed.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Creation.ProxyGeneratorResult.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.ProxyGeneratorResult"/> class. 
-            Creates a new instance representing a failed proxy
-            generation attempt due to an exception being caught.
-            </summary>
-            <param name="reasonForFailure">
-            The reason the proxy generation failed.
-            </param>
-            <param name="exception">
-            The exception thrown from the creation attempt.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Creation.ProxyGeneratorResult.#ctor(System.Object,FakeItEasy.Creation.ICallInterceptedEventRaiser)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.ProxyGeneratorResult"/> class. 
-            Creates a new instance representing a successful proxy
-            generation.
-            </summary>
-            <param name="generatedProxy">
-            The proxy that was generated.
-            </param>
-            <param name="callInterceptedEventRaiser">
-            An event raiser that raises
-            events when calls are intercepted to the proxy.
-            </param>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.ProxyWasSuccessfullyGenerated">
-            <summary>
-            Gets a value indicating whether the proxy was successfully created.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.GeneratedProxy">
-            <summary>
-            Gets the generated proxy when it was successfully created.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.CallInterceptedEventRaiser">
-            <summary>
-            Gets the event raiser that raises events when calls to the proxy are
-            intercepted.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.ReasonForFailure">
-            <summary>
-            Gets the reason for failure when the generation was not successful.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ICallExpressionParser">
-            <summary>
-            Represents a class that can parse a lambda expression
-            that represents a method or property call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ICallExpressionParser.Parse(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Parses the specified expression.
-            </summary>
-            <param name="callExpression">The expression to parse.</param>
-            <returns>The parsed expression.</returns>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionCallMatcher">
-            <summary>
-            Handles the matching of fake object calls to expressions.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallMatcher.#ctor(System.Linq.Expressions.LambdaExpression,FakeItEasy.Expressions.ExpressionArgumentConstraintFactory,FakeItEasy.Core.MethodInfoManager,FakeItEasy.Expressions.ICallExpressionParser)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Expressions.ExpressionCallMatcher"/> class.
-            </summary>
-            <param name="callSpecification">The call specification.</param>
-            <param name="constraintFactory">The constraint factory.</param>
-            <param name="methodInfoManager">The method info manager to use.</param>
-            <param name="callExpressionParser">A parser to use to parse call expressions.</param>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallMatcher.Matches(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Matches the specified call against the expression.
-            </summary>
-            <param name="call">The call to match.</param>
-            <returns>True if the call is matched by the expression.</returns>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallMatcher.ToString">
-            <summary>
-            Gets a description of the call.
-            </summary>
-            <returns>Description of the call.</returns>
-        </member>
-        <member name="P:FakeItEasy.Expressions.ExpressionCallMatcher.DescriptionOfMatchingCall">
-            <summary>
-            Gets a human readable description of calls that will be matched by this
-            matcher.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionCallRule">
-            <summary>
-            An implementation of the <see cref="T:FakeItEasy.Core.IFakeObjectCallRule"/> interface that uses
-            expressions for evaluating if the rule is applicable to a specific call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallRule.#ctor(FakeItEasy.Expressions.ExpressionCallMatcher)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Expressions.ExpressionCallRule"/> class.
-            </summary>
-            <param name="expressionMatcher">The expression matcher to use.</param>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallRule.ToString">
-            <summary>
-            Returns a <see cref="T:System.String"/> that represents this instance.
-            </summary>
-            <returns>
-            A <see cref="T:System.String"/> that represents this instance.
-            </returns>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionCallRule.Factory">
-            <summary>
-            Handles the instantiation of ExpressionCallRule instance.
-            </summary>
-            <param name="callSpecification">An expression specifying the call.</param>
-            <returns>A rule instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionParser">
-            <summary>
-            Manages breaking call specification expression into their various parts.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Expressions.IExpressionParser">
-            <summary>
-            Manages breaking call specification expression into their various parts.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.IExpressionParser.GetFakeManagerCallIsMadeOn(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Gets the fake object an expression is called on.
-            </summary>
-            <param name="fakeObjectCall">The call expression.</param>
-            <returns>The FakeManager instance that manages the faked object the call is made on.</returns>
-            <exception cref="T:System.ArgumentNullException">The fakeObjectCall is null.</exception>
-            <exception cref="T:System.ArgumentException">The specified expression is not an expression where a call is made to a faked object.</exception>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionParser.GetFakeManagerCallIsMadeOn(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Gets the fake object an expression is called on.
-            </summary>
-            <param name="fakeObjectCall">The call expression.</param>
-            <returns>A FakeObject.</returns>
-            <exception cref="T:System.ArgumentNullException">The fakeObjectCall is null.</exception>
-            <exception cref="T:System.ArgumentException">The specified expression is not an expression where a call is made to a faked object.</exception>
-        </member>
-        <member name="T:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax">
-            <summary>
-            Provides extension methods for configuring and asserting on faked objects
-            without going through the static methods of the Fake-class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax.CallsTo``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <typeparam name="TFake">The type of fake object to configure.</typeparam>
-            <typeparam name="TMember">The type of the return value of the member.</typeparam>
-            <param name="fakedObject">The faked object to configure.</param>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax.CallsTo``1(``0,System.Linq.Expressions.Expression{System.Action{``0}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <typeparam name="TFake">The type of fake object to configure.</typeparam>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax.AnyCall``1(``0)">
-            <summary>
-            Configures the behavior of the fake object when a call is made to any method on the
-            object.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-            <param name="fakedObject">The faked object.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.ExtensionSyntax.Syntax">
-            <summary>
-            Provides an extension method for configuring fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Syntax.Configure``1(``0)">
-            <summary>
-            Gets an object that provides a fluent interface syntax for configuring
-            the fake object.
-            </summary>
-            <typeparam name="TFake">The type of the fake object.</typeparam>
-            <param name="fakedObject">The fake object to configure.</param>
-            <returns>A configuration object.</returns>
-            <exception cref="T:System.ArgumentNullException">The fakedObject was null.</exception>
-            <exception cref="T:System.ArgumentException">The object passed in is not a faked object.</exception>
-        </member>
-        <member name="T:FakeItEasy.FakeAttribute">
-            <summary>
-            Used to tag fields and properties that will be initialized through the
-            Fake.Initialize-method.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.IoC.DictionaryContainer">
-            <summary>
-            A simple implementation of an IoC container.
-            </summary>
-        </member>
-        <member name="F:FakeItEasy.IoC.DictionaryContainer.registeredServices">
-            <summary>
-            The dictionary that stores the registered services.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.IoC.DictionaryContainer"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.Resolve(System.Type)">
-            <summary>
-            Resolves an instance of the specified component type.
-            </summary>
-            <param name="componentType">Type of the component.</param>
-            <returns>An instance of the component type.</returns>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.Register``1(System.Func{FakeItEasy.IoC.DictionaryContainer,``0})">
-            <summary>
-            Registers the specified resolver.
-            </summary>
-            <typeparam name="T">The type of component to register.</typeparam>
-            <param name="resolver">The resolver.</param>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.RegisterSingleton``1(System.Func{FakeItEasy.IoC.DictionaryContainer,``0})">
-            <summary>
-            Registers the specified resolver as a singleton.
-            </summary>
-            <typeparam name="T">The type of component to register.</typeparam>
-            <param name="resolver">The resolver.</param>
-        </member>
-        <member name="T:FakeItEasy.IRepeatSpecification">
-            <summary>
-            Provides properties and methods to specify repeat.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IRepeatSpecification.Times(System.Int32)">
-            <summary>
-            Specifies the number of times as repeat.
-            </summary>
-            <param name="numberOfTimes">The number of times expected.</param>
-            <returns>A Repeated instance.</returns>
-        </member>
-        <member name="P:FakeItEasy.IRepeatSpecification.Once">
-            <summary>
-            Specifies once as the repeat.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.IRepeatSpecification.Twice">
-            <summary>
-            Specifies twice as the repeat.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.OrderedAssertion">
-            <summary>
-            Provides functionality for making ordered assertions on fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.OrderedAssertion.OrderedAssertions(System.Collections.Generic.IEnumerable{FakeItEasy.Core.ICompletedFakeObjectCall})">
-            <summary>
-            Creates a scope that changes the behavior on asserts so that all asserts within
-            the scope must be to calls in the specified collection of calls. Calls must have happened
-            in the order that the asserts are specified or the asserts will fail.
-            </summary>
-            <param name="calls">The calls to assert among.</param>
-            <returns>A disposable used to close the scope.</returns>
-        </member>
-        <member name="T:FakeItEasy.FakeConfigurator`1">
-            <summary>
-            Provides the base implementation for the IFakeConfigurator-interface.
-            </summary>
-            <typeparam name="T">The type of fakes the configurator can configure.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.IFakeConfigurator">
-            <summary>
-            Provides configurations for fake objects of a specific type.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IFakeConfigurator.ConfigureFake(System.Object)">
-            <summary>
-            Applies the configuration for the specified fake object.
-            </summary>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="P:FakeItEasy.IFakeConfigurator.ForType">
-            <summary>
-            Gets the type the instance provides configuration for.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.FakeConfigurator`1.ConfigureFake(`0)">
-            <summary>
-            Configures the fake.
-            </summary>
-            <param name="fakeObject">The fake object.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeConfigurator`1.FakeItEasy#IFakeConfigurator#ConfigureFake(System.Object)">
-            <summary>
-            Applies the configuration for the specified fake object.
-            </summary>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeConfigurator`1.AssertThatFakeIsOfCorrectType(System.Object)">
-            <summary>
-            Asserts the type of the that fake is of correct.
-            </summary>
-            <param name="fakeObject">The fake object.</param>
-        </member>
-        <member name="P:FakeItEasy.FakeConfigurator`1.ForType">
-            <summary>
-            Gets the type the instance provides configuration for.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.DummyDefinition`1">
-            <summary>
-            Represents a definition of how a fake object of the type T should
-            be created.
-            </summary>
-            <typeparam name="T">The type of fake.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.IDummyDefinition">
-            <summary>
-            Represents a definition of how dummies of the specified type should be created.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IDummyDefinition.CreateDummy">
-            <summary>
-            Creates the fake.
-            </summary>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="P:FakeItEasy.IDummyDefinition.ForType">
-            <summary>
-            Gets the type of fake object the definition is for.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.DummyDefinition`1.FakeItEasy#IDummyDefinition#CreateDummy">
-            <summary>
-            Creates the dummy.
-            </summary>
-            <returns>The dummy object.</returns>
-        </member>
-        <member name="M:FakeItEasy.DummyDefinition`1.CreateDummy">
-            <summary>
-            Creates the dummy.
-            </summary>
-            <returns>The dummy object.</returns>
-        </member>
-        <member name="P:FakeItEasy.DummyDefinition`1.ForType">
-            <summary>
-            Gets the type the definition is for.
-            </summary>
-            <value>For type.</value>
-        </member>
-        <member name="T:FakeItEasy.ArgumentConstraintExtensions">
-            <summary>
-            Provides validation extensions for <see cref="T:FakeItEasy.IArgumentConstraintManager`1"/>.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsNull``1(FakeItEasy.IArgumentConstraintManager{``0})">
-            <summary>
-            Constrains an argument so that it must be null (Nothing in VB).
-            </summary>
-            <typeparam name="T">The type of the argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Contains(FakeItEasy.IArgumentConstraintManager{System.String},System.String)">
-            <summary>
-            Constrains the string argument to contain the specified text.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The string the argument string should contain.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Contains``1(FakeItEasy.IArgumentConstraintManager{``0},System.Object)">
-            <summary>
-            Constrains the sequence so that it must contain the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the collection should contain.</param>
-            <typeparam name="T">The type of sequence.</typeparam>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.StartsWith(FakeItEasy.IArgumentConstraintManager{System.String},System.String)">
-            <summary>
-            Constrains the string so that it must start with the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the string should start with.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.EndsWith(FakeItEasy.IArgumentConstraintManager{System.String},System.String)">
-            <summary>
-            Constrains the string so that it must end with the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the string should end with.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsNullOrEmpty(FakeItEasy.IArgumentConstraintManager{System.String})">
-            <summary>
-            Constrains the string so that it must be null or empty.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsGreaterThan``1(FakeItEasy.IArgumentConstraintManager{``0},``0)">
-            <summary>
-            Constrains argument value so that it must be greater than the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the string should start with.</param>
-            <typeparam name="T">The type of argument to constrain.</typeparam>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsSameSequenceAs``1(FakeItEasy.IArgumentConstraintManager{``0},System.Collections.IEnumerable)">
-            <summary>
-            The tested argument collection should contain the same elements as the
-            as the specified collection.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The sequence to test against.</param>
-            <typeparam name="T">The type of argument to constrain.</typeparam>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsEmpty``1(FakeItEasy.IArgumentConstraintManager{``0})">
-            <summary>
-            Tests that the IEnumerable contains no items.
-            </summary>
-            <typeparam name="T">The type of argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsEqualTo``1(FakeItEasy.IArgumentConstraintManager{``0},``0)">
-            <summary>
-            Tests that the passed in argument is equal to the specified value.
-            </summary>
-            <typeparam name="T">The type of the argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value to compare to.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsSameAs``1(FakeItEasy.IArgumentConstraintManager{``0},``0)">
-            <summary>
-            Tests that the passed in argument is the same instance (reference) as the specified value.
-            </summary>
-            <typeparam name="T">The type of the argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The reference to compare to.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsInstanceOf``1(FakeItEasy.IArgumentConstraintManager{``0},System.Type)">
-            <summary>
-            Constrains the argument to be of the specified type.
-            </summary>
-            <typeparam name="T">The type of argument in the method signature.</typeparam>
-            <param name="manager">The constraint manager.</param>
-            <param name="type">The type to constrain the argument with.</param>
-            <returns>A dummy value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Matches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Func{``0,System.Boolean},System.String)">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="scope">
-            The constraint manager.
-            </param>
-            <param name="predicate">
-            The predicate that should constrain the argument.
-            </param>
-            <param name="description">
-            A human readable description of the constraint.
-            </param>
-            <typeparam name="T">
-            The type of argument in the method signature.
-            </typeparam>
-            <returns>
-            A dummy argument value.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Matches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Func{``0,System.Boolean},System.String,System.Object[])">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="manager">
-            The constraint manager.
-            </param>
-            <param name="predicate">
-            The predicate that should constrain the argument.
-            </param>
-            <param name="descriptionFormat">
-            A human readable description of the constraint format string.
-            </param>
-            <param name="args">
-            Arguments for the format string.
-            </param>
-            <typeparam name="T">
-            The type of argument in the method signature.
-            </typeparam>
-            <returns>
-            A dummy argument value.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Matches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="scope">
-            The constraint manager.
-            </param>
-            <param name="predicate">
-            The predicate that should constrain the argument.
-            </param>
-            <typeparam name="T">
-            The type of argument in the method signature.
-            </typeparam>
-            <returns>
-            A dummy argument value.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.NullCheckedMatches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Func{``0,System.Boolean},System.Action{FakeItEasy.IOutputWriter})">
-            <summary>
-            Constrains the argument to be not null (Nothing in VB) and to match
-            the specified predicate.
-            </summary>
-            <typeparam name="T">The type of the argument to constrain.</typeparam>
-            <param name="manager">The constraint manager.</param>
-            <param name="predicate">The predicate that constrains non null values.</param>
-            <param name="descriptionWriter">An action that writes a description of the constraint
-            to the output.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="T:FakeItEasy.OutputWriter">
-            <summary>
-            Provides static methods for the IOutputWriter-interface.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.OutputWriter.WriteLine(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a new line to the writer.
-            </summary>
-            <param name="writer">The writer to write to.</param>
-            <returns>The writer.</returns>
-        </member>
-        <member name="M:FakeItEasy.OutputWriter.Write(FakeItEasy.IOutputWriter,System.String,System.Object[])">
-            <summary>
-            Writes the format string to the writer.
-            </summary>
-            <param name="writer">The writer to write to.</param>
-            <param name="format">The format string to write.</param>
-            <param name="args">Replacements for the format string.</param>
-            <returns>The writer.</returns>
-        </member>
-        <member name="M:FakeItEasy.OutputWriter.Write(FakeItEasy.IOutputWriter,System.Object)">
-            <summary>
-            Writes the specified object to the writer (using the ToString-method of the object).
-            </summary>
-            <param name="writer">The writer to write to.</param>
-            <param name="value">The value to write to the writer.</param>
-            <returns>The writer.</returns>
-        </member>
-        <member name="T:FakeItEasy.Repeated">
-            <summary>
-            Provides syntax for specifying the number of times a call must have been repeated when asserting on 
-            fake object calls.
-            </summary>
-            <example><code>A.CallTo(() => foo.Bar()).Assert(Happened.Once.Exactly);</code></example>
-        </member>
-        <member name="M:FakeItEasy.Repeated.Like(System.Linq.Expressions.Expression{System.Func{System.Int32,System.Boolean}})">
-            <summary>
-            Specifies that a call must have been repeated a number of times
-            that is validated by the specified repeatValidation argument.
-            </summary>
-            <param name="repeatValidation">A predicate that specifies the number of times
-            a call must have been made.</param>
-            <returns>A Repeated-instance.</returns>
-        </member>
-        <member name="M:FakeItEasy.Repeated.Matches(System.Int32)">
-            <summary>
-            When implemented gets a value indicating if the repeat is matched
-            by the Happened-instance.
-            </summary>
-            <param name="repeat">The repeat of a call.</param>
-            <returns>True if the repeat is a match.</returns>
-        </member>
-        <member name="P:FakeItEasy.Repeated.Never">
-            <summary>
-            Asserts that a call has not happened at all.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Repeated.Exactly">
-            <summary>
-            The call must have happened exactly the number of times that is specified in the next step.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Repeated.AtLeast">
-            <summary>
-            The call must have happened any number of times greater than or equal to the number of times that is specified
-            in the next step.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Repeated.NoMoreThan">
-            <summary>
-            The call must have happened any number of times less than or equal to the number of times that is specified
-            in the next step.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Recorders">
-            <summary>
-            Provides methods for creating recorders for self initializing fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Recorders.FileRecorder(System.String)">
-            <summary>
-            Gets a recorder that records to and loads calls from the specified file.
-            </summary>
-            <param name="fileName">The file to use for recording.</param>
-            <returns>A recorder instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.IFileSystem">
-            <summary>
-            Provides access to the file system.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IFileSystem.Open(System.String,System.IO.FileMode)">
-            <summary>
-            Opens the specified file in the specified mode.
-            </summary>
-            <param name="fileName">The full path and name of the file to open.</param>
-            <param name="mode">The mode to open the file in.</param>
-            <returns>A stream for reading and writing the file.</returns>
-        </member>
-        <member name="M:FakeItEasy.IFileSystem.FileExists(System.String)">
-            <summary>
-            Gets a value indicating whether the specified file exists.
-            </summary>
-            <param name="fileName">The path and name of the file to check.</param>
-            <returns>True if the file exists.</returns>
-        </member>
-        <member name="M:FakeItEasy.IFileSystem.Create(System.String)">
-            <summary>
-            Creates a file with the specified name.
-            </summary>
-            <param name="fileName">The name of the file to create.</param>
-        </member>
-        <member name="M:FakeItEasy.Helpers.GetValueProducedByExpression(System.Linq.Expressions.Expression)">
-            <summary>
-            Gets the value produced by the specified expression when compiled and invoked.
-            </summary>
-            <param name="expression">The expression to get the value from.</param>
-            <returns>The value produced by the expression.</returns>
-        </member>
-        <member name="T:FakeItEasy.ExpectationException">
-            <summary>
-            An exception thrown when an expectation is not met (when asserting on fake object calls).
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
-            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
-            <exception cref="T:System.ArgumentNullException">
-            The <paramref name="info"/> parameter is null.
-            </exception>
-            <exception cref="T:System.Runtime.Serialization.SerializationException">
-            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
-            </exception>
-        </member>
-        <member name="T:FakeItEasy.FakeExtensions">
-            <summary>
-            Provides extension methods for fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Once(FakeItEasy.Configuration.IRepeatConfiguration)">
-            <summary>
-            Specifies NumberOfTimes(1) to the IRepeatConfiguration{TFake}.
-            </summary>
-            <param name="configuration">The configuration to set repeat 1 to.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Twice(FakeItEasy.Configuration.IRepeatConfiguration)">
-            <summary>
-            Specifies NumberOfTimes(2) to the IRepeatConfiguration{TFake}.
-            </summary>
-            <param name="configuration">The configuration to set repeat 2 to.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.WithAnyArguments``1(FakeItEasy.Configuration.IArgumentValidationConfiguration{``0})">
-            <summary>
-            Specifies that a call to the configured call should be applied no matter what arguments
-            are used in the call to the faked object.
-            </summary>
-            <typeparam name="TInterface">The type of the interface.</typeparam>
-            <param name="configuration">The configuration.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Matching``1(System.Collections.Generic.IEnumerable{FakeItEasy.Core.ICompletedFakeObjectCall},System.Linq.Expressions.Expression{System.Action{``0}})">
-            <summary>
-            Filters to contain only the calls that matches the call specification.
-            </summary>
-            <typeparam name="TFake">The type of fake the call is made on.</typeparam>
-            <param name="calls">The calls to filter.</param>
-            <param name="callSpecification">The call to match on.</param>
-            <returns>A collection of the calls that matches the call specification.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.MustHaveHappened(FakeItEasy.Configuration.IAssertConfiguration)">
-            <summary>
-            Asserts that the specified call must have happened once or more.
-            </summary>
-            <param name="configuration">The configuration to assert on.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.MustNotHaveHappened(FakeItEasy.Configuration.IAssertConfiguration)">
-            <summary>
-            Asserts that the specified has not happened.
-            </summary>
-            <param name="configuration">The configuration to assert on.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsNextFromSequence``1(FakeItEasy.Configuration.IReturnValueConfiguration{``0},``0[])">
-            <summary>
-            Configures the call to return the next value from the specified sequence each time it's called. Null will
-            be returned when all the values in the sequence has been returned.
-            </summary>
-            <typeparam name="T">
-            The type of return value.
-            </typeparam>
-            <param name="configuration">
-            The call configuration to extend.
-            </param>
-            <param name="values">
-            The values to return in sequence.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Returns``1(FakeItEasy.Configuration.IReturnValueConfiguration{``0},``0)">
-            <summary>
-            Specifies the value to return when the configured call is made.
-            </summary>
-            <typeparam name="T">The type of the return value.</typeparam>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="value">The value to return.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``1(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <typeparam name="T">The type of the return value.</typeparam>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``2(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``3(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``2,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``4(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``2,``3,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``5(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``2,``3,``4,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the faked method call.</typeparam>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Write``1(System.Collections.Generic.IEnumerable{``0},FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes the calls in the collection to the specified text writer.
-            </summary>
-            <typeparam name="T">The type of the calls.</typeparam>
-            <param name="calls">The calls to write.</param>
-            <param name="writer">The writer to write the calls to.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.WriteToConsole``1(System.Collections.Generic.IEnumerable{``0})">
-            <summary>
-            Writes all calls in the collection to the console.
-            </summary>
-            <typeparam name="T">The type of the calls.</typeparam>
-            <param name="calls">The calls to write.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.GetArgument``1(FakeItEasy.Core.IFakeObjectCall,System.Int32)">
-            <summary>
-            Gets the argument at the specified index in the arguments collection
-            for the call.
-            </summary>
-            <typeparam name="T">The type of the argument to get.</typeparam>
-            <param name="call">The call to get the argument from.</param>
-            <param name="argumentIndex">The index of the argument.</param>
-            <returns>The value of the argument with the specified index.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.GetArgument``1(FakeItEasy.Core.IFakeObjectCall,System.String)">
-            <summary>
-            Gets the argument with the specified name in the arguments collection
-            for the call.
-            </summary>
-            <typeparam name="T">The type of the argument to get.</typeparam>
-            <param name="call">The call to get the argument from.</param>
-            <param name="argumentName">The name of the argument.</param>
-            <returns>The value of the argument with the specified name.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Strict``1(FakeItEasy.Creation.IFakeOptionsBuilder{``0})">
-            <summary>
-            Makes the fake strict, this means that any call to the fake
-            that has not been explicitly configured will throw an exception.
-            </summary>
-            <typeparam name="T">The type of fake object.</typeparam>
-            <param name="options">The configuration.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Where``1(FakeItEasy.Configuration.IWhereConfiguration{``0},System.Linq.Expressions.Expression{System.Func{FakeItEasy.Core.IFakeObjectCall,System.Boolean}})">
-            <summary>
-            Applies a predicate to constrain which calls will be considered for interception.
-            </summary>
-            <typeparam name="T">
-            The return type of the where method.
-            </typeparam>
-            <param name="configuration">
-            The configuration object to extend.
-            </param>
-            <param name="predicate">
-            A predicate for a fake object call.
-            </param>
-            to the output.
-            <returns>
-            The configuration object.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``1(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action)">
-            <summary>
-            Executes the specified action when a matching call is being made. This overload can also be used to fake calls with arguments when they don't need to be accessed.
-            </summary>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action"/> to invoke.</param>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``2(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`1"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``3(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1,``2})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`2"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``4(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1,``2,``3})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`3"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``5(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1,``2,``3,``4})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`4"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Exception)">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exception">The exception to throw when a call that matches is invoked.</param>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``1(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``2(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,``1,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``3(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,``1,``2,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``4(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,``1,``2,``3,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``1(FakeItEasy.Configuration.IExceptionThrowerConfiguration)">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <typeparam name="T">The type of exception to throw.</typeparam>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.ArgumentCollection">
-            <summary>
-              A collection of method arguments.
-            </summary>
-        </member>
-        <member name="F:FakeItEasy.ArgumentCollection.arguments">
-            <summary>
-              The arguments this collection contains.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.#ctor(System.Object[],System.Collections.Generic.IEnumerable{System.String})">
-            <summary>
-              Initializes a new instance of the <see cref="T:FakeItEasy.ArgumentCollection"/> class.
-            </summary>
-            <param name="arguments">The arguments.</param>
-            <param name="argumentNames">The argument names.</param>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.#ctor(System.Object[],System.Reflection.MethodInfo)">
-            <summary>
-              Initializes a new instance of the <see cref="T:FakeItEasy.ArgumentCollection"/> class.
-            </summary>
-            <param name="arguments">The arguments.</param>
-            <param name="method">The method.</param>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.GetEnumerator">
-            <summary>
-              Returns an enumerator that iterates through the collection or arguments.
-            </summary>
-            <returns>
-              A <see cref = "T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.Get``1(System.Int32)">
-            <summary>
-              Gets the argument at the specified index.
-            </summary>
-            <typeparam name = "T">The type of the argument to get.</typeparam>
-            <param name = "index">The index of the argument.</param>
-            <returns>The argument at the specified index.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.Get``1(System.String)">
-            <summary>
-              Gets the argument with the specified name.
-            </summary>
-            <typeparam name = "T">The type of the argument to get.</typeparam>
-            <param name = "argumentName">The name of the argument.</param>
-            <returns>The argument with the specified name.</returns>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.Empty">
-            <summary>
-              Gets an empty ArgumentList.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.Count">
-            <summary>
-              Gets the number of arguments in the list.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.ArgumentNames">
-            <summary>
-              Gets the names of the arguments in the list.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.Item(System.Int32)">
-            <summary>
-              Gets the argument at the specified index.
-            </summary>
-            <param name = "argumentIndex">The index of the argument to get.</param>
-            <returns>The argument at the specified index.</returns>
-        </member>
-        <member name="T:FakeItEasy.Guard">
-            <summary>
-            Provides methods for guarding method arguments.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Guard.AgainstNull(System.Object,System.String)">
-            <summary>
-            Throws an exception if the specified argument is null.
-            </summary>
-            <param name="argument">The argument.</param>
-            <param name="argumentName">Name of the argument.</param>
-            <exception cref="T:System.ArgumentNullException">The specified argument was null.</exception>
-        </member>
-        <member name="T:FakeItEasy.Guard.ValidatedNotNullAttribute">
-            <summary>
-            When applied to a parameter, this attribute provides an indication to code analysis that the argument has been null checked.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Fake">
-            <summary>
-            Provides static methods for accessing fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Fake.GetFakeManager(System.Object)">
-            <summary>
-            Gets the fake object that manages the faked object.
-            </summary>
-            <param name="fakedObject">The faked object to get the manager object for.</param>
-            <returns>The fake object manager.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.CreateScope">
-            <summary>
-            Creates a new scope and sets it as the current scope. When inside a scope the
-            getting the calls made to a fake will return only the calls within that scope and when
-            asserting that calls were made, the calls must have been made within that scope.
-            </summary>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.CreateScope(FakeItEasy.Core.IFakeObjectContainer)">
-            <summary>
-            Creates a new scope and sets it as the current scope. When inside a scope the
-            getting the calls made to a fake will return only the calls within that scope and when
-            asserting that calls were made, the calls must have been made within that scope.
-            </summary>
-            <param name="container">The container to use within the specified scope.</param>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.Equals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are equal.
-            </summary>
-            <param name="objA">The first object to compare.</param>
-            <param name="objB">The second object to compare.</param>
-            <returns>True if the two objects are equal.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.ReferenceEquals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are the same reference.
-            </summary>
-            <param name="objA">The object A.</param>
-            <param name="objB">The object B.</param>
-            <returns>True if the objects are the same reference.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.GetCalls(System.Object)">
-            <summary>
-            Gets all the calls made to the specified fake object.
-            </summary>
-            <param name="fakedObject">The faked object.</param>
-            <returns>A collection containing the calls to the object.</returns>
-            <exception cref="T:System.ArgumentException">The object passed in is not a faked object.</exception>
-        </member>
-        <member name="M:FakeItEasy.Fake.ClearConfiguration(System.Object)">
-            <summary>
-            Clears the configuration of the faked object.
-            </summary>
-            <param name="fakedObject">The faked object to clear the configuration of.</param>
-        </member>
-        <member name="M:FakeItEasy.Fake.InitializeFixture(System.Object)">
-            <summary>
-            Sets a new fake to each property or field that is tagged with the FakeAttribute in the specified
-            fixture.
-            </summary>
-            <param name="fixture">The object to initialize.</param>
-        </member>
-        <member name="T:FakeItEasy.Raise">
-            <summary>
-            Allows the developer to raise an event on a faked object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Raise.With``1(System.Object,``0)">
-            <summary>
-            Raises an event on a faked object by attaching the event handler produced by the method
-            to the event that is to be raised.
-            </summary>
-            <typeparam name="TEventArgs">The type of the event args.</typeparam>
-            <param name="sender">The sender of the event.</param>
-            <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
-            <returns>A Raise(TEventArgs)-object that exposes the event handler to attach.</returns>
-        </member>
-        <member name="M:FakeItEasy.Raise.With``1(``0)">
-            <summary>
-            Raises an event on a faked object by attaching the event handler produced by the method
-            to the event that is to be raised.
-            </summary>
-            <typeparam name="TEventArgs">The type of the event arguments.</typeparam>
-            <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
-            <returns>
-            A Raise(TEventArgs)-object that exposes the event handler to attach.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Raise.WithEmpty">
-            <summary>
-            Raises an event with empty event arguments on a faked object by attaching the event handler produced by the method
-            to the event that is to be raised.
-            </summary>
-            <returns>
-            A Raise(TEventArgs)-object that exposes the event handler to attach.
-            </returns>
-        </member>
-        <member name="T:FakeItEasy.RootModule">
-            <summary>
-            Handles the registration of root dependencies in an IoC-container.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.RootModule.RegisterDependencies(FakeItEasy.IoC.DictionaryContainer)">
-            <summary>
-            Registers the dependencies.
-            </summary>
-            <param name="container">The container to register the dependencies in.</param>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.CallData">
-            <summary>
-            DTO for recorded calls.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.CallData.#ctor(System.Reflection.MethodInfo,System.Collections.Generic.IEnumerable{System.Object},System.Object)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.CallData"/> class.
-            </summary>
-            <param name="method">The method.</param>
-            <param name="outputArguments">The output arguments.</param>
-            <param name="returnValue">The return value.</param>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.CallData.Method">
-            <summary>
-            Gets the method that was called.
-            </summary>
-            <value>The method.</value>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.CallData.OutputArguments">
-            <summary>
-            Gets the output arguments of the call.
-            </summary>
-            <value>The output arguments.</value>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.CallData.ReturnValue">
-            <summary>
-            Gets the return value of the call.
-            </summary>
-            <value>The return value.</value>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.ICallStorage">
-            <summary>
-            Represents storage for recorded calls for self initializing
-            fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ICallStorage.Load">
-            <summary>
-            Loads the recorded calls for the specified recording.
-            </summary>
-            <returns>The recorded calls for the recording with the specified id.</returns>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ICallStorage.Save(System.Collections.Generic.IEnumerable{FakeItEasy.SelfInitializedFakes.CallData})">
-            <summary>
-            Saves the specified calls as the recording with the specified id,
-            overwriting any previous recording.
-            </summary>
-            <param name="calls">The calls to save.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.FileStorage.#ctor(System.String,FakeItEasy.IFileSystem)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.FileStorage"/> class.
-            </summary>
-            <param name="fileName">Name of the file.</param>
-            <param name="fileSystem">The file system.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.FileStorage.Load">
-            <summary>
-            Loads the recorded calls for the specified recording.
-            </summary>
-            <returns>
-            The recorded calls for the recording with the specified id.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.FileStorage.Save(System.Collections.Generic.IEnumerable{FakeItEasy.SelfInitializedFakes.CallData})">
-            <summary>
-            Saves the specified calls as the recording with the specified id,
-            overwriting any previous recording.
-            </summary>
-            <param name="calls">The calls to save.</param>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.FileStorage.Factory">
-            <summary>
-            A factory responsible for creating instances of FileStorage.
-            </summary>
-            <param name="fileName">The file name of the storage.</param>
-            <returns>A FileStorage instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder">
-            <summary>
-            An interface for recorders that provides stored responses for self initializing fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder.ApplyNext(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies the call if the call has been recorded.
-            </summary>
-            <param name="fakeObjectCall">The call to apply to from recording.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder.RecordCall(FakeItEasy.Core.ICompletedFakeObjectCall)">
-            <summary>
-            Records the specified call.
-            </summary>
-            <param name="fakeObjectCall">The call to record.</param>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder.IsRecording">
-            <summary>
-            Gets a value indicating whether the recorder is currently recording.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.RecordingException">
-            <summary>
-            An exception that can be thrown when recording for self initialized
-            fakes fails or when playback fails.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
-            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
-            <exception cref="T:System.ArgumentNullException">
-            The <paramref name="info"/> parameter is null.
-            </exception>
-            <exception cref="T:System.Runtime.Serialization.SerializationException">
-            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
-            </exception>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.RecordingManager">
-            <summary>
-            Manages the applying of recorded calls and recording of new calls when
-            using self initialized fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.#ctor(FakeItEasy.SelfInitializedFakes.ICallStorage)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingManager"/> class.
-            </summary>
-            <param name="storage">The storage.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.ApplyNext(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies the call if the call has been recorded.
-            </summary>
-            <param name="fakeObjectCall">The call to apply to from recording.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.RecordCall(FakeItEasy.Core.ICompletedFakeObjectCall)">
-            <summary>
-            Records the specified call.
-            </summary>
-            <param name="fakeObjectCall">The call to record.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.Dispose">
-            <summary>
-            Saves all recorded calls to the storage.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.RecordingManager.IsRecording">
-            <summary>
-            Gets a value indicating whether the recorder is currently recording.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.RecordingManager.Factory">
-            <summary>
-            Represents a factory responsible for creating recording manager
-            instances.
-            </summary>
-            <param name="storage">The storage the manager should use.</param>
-            <returns>A RecordingManager instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.SelfInitializationRule">
-            <summary>
-            A call rule use for self initializing fakes, delegates call to
-            be applied by the recorder.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.#ctor(FakeItEasy.Core.IFakeObjectCallRule,FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.SelfInitializationRule"/> class.
-            </summary>
-            <param name="wrappedRule">The wrapped rule.</param>
-            <param name="recorder">The recorder.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets whether this interceptor is applicable to the specified
-            call, if true is returned the Apply-method of the interceptor will
-            be called.
-            </summary>
-            <param name="fakeObjectCall">The call to check for applicability.</param>
-            <returns>True if the interceptor is applicable.</returns>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.Apply(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies an action to the call, might set a return value or throw
-            an exception.
-            </summary>
-            <param name="fakeObjectCall">The call to apply the interceptor to.</param>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.NumberOfTimesToCall">
-            <summary>
-            Gets the number of times this call rule is valid, if it's set
-            to null its infinitely valid.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.CommonExtensions">
-            <summary>
-            Provides extension methods for the common uses.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.FormatInvariant(System.String,System.Object[])">
-            <summary>
-            Replaces the format item in a specified System.String with the text equivalent
-            of the value of a corresponding System.Object instance in a specified array using
-            invariant culture as <see cref="T:System.IFormatProvider"/>.
-            </summary>
-            <param name="format">A composite format string.</param>
-            <param name="arguments">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
-            <returns>The formatted string.</returns>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.Zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
-            <summary>
-            Gets an enumerable of tuples where the first value of each tuple is a value
-            from the first collection and the second value of each tuple is the value at the same position
-            from the second collection.
-            </summary>
-            <typeparam name="TFirst">The type of values in the first collection.</typeparam>
-            <typeparam name="TSecond">The type of values in the second collection.</typeparam>
-            <param name="firstCollection">The first of the collections to combine.</param>
-            <param name="secondCollection">The second of the collections to combine.</param>
-            <returns>An enumerable of tuples.</returns>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.ToCollectionString``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.String},System.String)">
-            <summary>
-            Joins the collection to a string.
-            </summary>
-            <typeparam name="T">The type of items in the collection.</typeparam>
-            <param name="items">The items to join.</param>
-            <param name="stringConverter">A function that converts from an item to a string value.</param>
-            <param name="separator">Separator to insert between each item.</param>
-            <returns>A string representation of the collection.</returns>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.FirstFromEachKey``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
-            <summary>
-            Gets a dictionary containing the first element from the sequence that has a key specified by the key selector.
-            </summary>
-            <typeparam name="T">The type of items in the sequence.</typeparam>
-            <typeparam name="TKey">The type of the key.</typeparam>
-            <param name="sequence">The sequence.</param>
-            <param name="keySelector">The key selector.</param>
-            <returns>A dictionary.</returns>
-        </member>
-        <member name="T:FakeItEasy.SmellyAttribute">
-            <summary>
-            An attribute that can be applied to code that should be fixed because there's a
-            code smell.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.SmellyAttribute.Description">
-            <summary>
-            Gets or sets the description of the smell.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.NextCall">
-            <summary>
-            Lets you specify options for the next call to a fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.NextCall.To``1(``0)">
-            <summary>
-            Specifies options for the next call to the specified fake object. The next call will
-            be recorded as a call configuration.
-            </summary>
-            <typeparam name="TFake">The type of the faked object.</typeparam>
-            <param name="fake">The faked object to configure.</param>
-            <returns>A call configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.UnderTestAttribute">
-            <summary>
-            Used to tag fields and properties that will be initialized as a SUT through the Fake.Initialize-method.
-            </summary>
-        </member>
-    </members>
-</doc>
diff --git a/dep/FakeItEasy.1.15.0/lib/sl40/FakeItEasy.dll b/dep/FakeItEasy.1.15.0/lib/sl40/FakeItEasy.dll
deleted file mode 100644
index b8029c091e7fc881bbfef5fc0c5294fbf96f9f49..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 473088
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%0DDCk+(NO4SW1>8#uPx!c
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
a{2#xXlzo%k#D2s5k5~NviT^M3!2bfL$?mBD

diff --git a/dep/FakeItEasy.1.15.0/lib/sl40/FakeItEasy.xml b/dep/FakeItEasy.1.15.0/lib/sl40/FakeItEasy.xml
deleted file mode 100644
index f865bf86973..00000000000
--- a/dep/FakeItEasy.1.15.0/lib/sl40/FakeItEasy.xml
+++ /dev/null
@@ -1,3424 +0,0 @@
-<?xml version="1.0"?>
-<doc>
-    <assembly>
-        <name>FakeItEasy</name>
-    </assembly>
-    <members>
-        <member name="T:FakeItEasy.A">
-            <summary>
-            Provides methods for generating fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.A.Fake``1">
-            <summary>
-            Creates a fake object of the type T.
-            </summary>
-            <typeparam name="T">The type of fake object to create.</typeparam>
-            <returns>A fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.Fake``1(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{``0}})">
-            <summary>
-            Creates a fake object of the type T.
-            </summary>
-            <typeparam name="T">The type of fake object to create.</typeparam>
-            <param name="options">A lambda where options for the built fake object can be specified.</param>
-            <returns>A fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.CollectionOfFake``1(System.Int32)">
-            <summary>
-            Creates a collection of fakes of the specified type.
-            </summary>
-            <typeparam name="T">The type of fakes to create.</typeparam>
-            <param name="numberOfFakes">The number of fakes in the collection.</param>
-            <returns>A collection of fake objects of the specified type.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.Dummy``1">
-            <summary>
-            Gets a dummy object of the specified type. The value of a dummy object
-            should be irrelevant. Dummy objects should not be configured.
-            </summary>
-            <typeparam name="T">The type of dummy to return.</typeparam>
-            <returns>A dummy object of the specified type.</returns>
-            <exception cref="T:System.ArgumentException">Dummies of the specified type can not be created.</exception>
-        </member>
-        <member name="M:FakeItEasy.A.Equals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are equal.
-            </summary>
-            <param name="objA">The first object to compare.</param>
-            <param name="objB">The second object to compare.</param>
-            <returns>True if the two objects are equal.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.ReferenceEquals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are the same reference.
-            </summary>
-            <param name="objA">The object A.</param>
-            <param name="objB">The object B.</param>
-            <returns>True if the objects are the same reference.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.CallTo(System.Linq.Expressions.Expression{System.Action})">
-            <summary>
-            Configures a call to a faked object.
-            </summary>
-            <param name="callSpecification">An expression where the configured member is called.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.A.CallTo(System.Object)">
-            <summary>
-            Gets a configuration object allowing for further configuration of
-            any call to the specified faked object.
-            </summary>
-            <param name="fake">
-            The fake to configure.
-            </param>
-            <returns>
-            A configuration object.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.A.CallTo``1(System.Linq.Expressions.Expression{System.Func{``0}})">
-            <summary>
-            Configures a call to a faked object.
-            </summary>
-            <typeparam name="T">The type of member on the faked object to configure.</typeparam>
-            <param name="callSpecification">An expression where the configured member is called.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.A`1">
-            <summary>
-            Provides an API entry point for constraining arguments of fake object calls.
-            </summary>
-            <typeparam name="T">The type of argument to validate.</typeparam>
-        </member>
-        <member name="P:FakeItEasy.A`1.That">
-            <summary>
-            Gets an argument constraint object that will be used to constrain a method call argument.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.A`1._">
-            <summary>
-            Gets a constraint that considers any value of an argument as valid.
-            </summary>
-            <remarks>This is a shortcut for the "Ignored"-property.</remarks>
-        </member>
-        <member name="P:FakeItEasy.A`1.Ignored">
-            <summary>
-            Gets a constraint that considers any value of an argument as valid.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Any">
-            <summary>
-            Provides configuration for any (not a specific) call on a faked object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Any.CallTo(System.Object)">
-            <summary>
-            Gets a configuration object allowing for further configuration of
-            any call to the specified faked object.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Any.Equals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are equal.
-            </summary>
-            <param name="objA">The first object to compare.</param>
-            <param name="objB">The second object to compare.</param>
-            <returns>True if the two objects are equal.</returns>
-        </member>
-        <member name="M:FakeItEasy.Any.ReferenceEquals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are the same reference.
-            </summary>
-            <param name="objA">The object A.</param>
-            <param name="objB">The object B.</param>
-            <returns>True if the objects are the same reference.</returns>
-        </member>
-        <member name="T:FakeItEasy.ArgumentCollection">
-            <summary>
-              A collection of method arguments.
-            </summary>
-        </member>
-        <member name="F:FakeItEasy.ArgumentCollection.arguments">
-            <summary>
-              The arguments this collection contains.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.#ctor(System.Object[],System.Collections.Generic.IEnumerable{System.String})">
-            <summary>
-              Initializes a new instance of the <see cref="T:FakeItEasy.ArgumentCollection"/> class.
-            </summary>
-            <param name="arguments">The arguments.</param>
-            <param name="argumentNames">The argument names.</param>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.#ctor(System.Object[],System.Reflection.MethodInfo)">
-            <summary>
-              Initializes a new instance of the <see cref="T:FakeItEasy.ArgumentCollection"/> class.
-            </summary>
-            <param name="arguments">The arguments.</param>
-            <param name="method">The method.</param>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.GetEnumerator">
-            <summary>
-              Returns an enumerator that iterates through the collection or arguments.
-            </summary>
-            <returns>
-              A <see cref = "T:System.Collections.Generic.IEnumerator`1" /> that can be used to iterate through the collection.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.Get``1(System.Int32)">
-            <summary>
-              Gets the argument at the specified index.
-            </summary>
-            <typeparam name = "T">The type of the argument to get.</typeparam>
-            <param name = "index">The index of the argument.</param>
-            <returns>The argument at the specified index.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentCollection.Get``1(System.String)">
-            <summary>
-              Gets the argument with the specified name.
-            </summary>
-            <typeparam name = "T">The type of the argument to get.</typeparam>
-            <param name = "argumentName">The name of the argument.</param>
-            <returns>The argument with the specified name.</returns>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.Empty">
-            <summary>
-              Gets an empty ArgumentList.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.Count">
-            <summary>
-              Gets the number of arguments in the list.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.ArgumentNames">
-            <summary>
-              Gets the names of the arguments in the list.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentCollection.Item(System.Int32)">
-            <summary>
-              Gets the argument at the specified index.
-            </summary>
-            <param name = "argumentIndex">The index of the argument to get.</param>
-            <returns>The argument at the specified index.</returns>
-        </member>
-        <member name="T:FakeItEasy.ArgumentConstraintExtensions">
-            <summary>
-            Provides validation extensions for <see cref="T:FakeItEasy.IArgumentConstraintManager`1"/>.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsNull``1(FakeItEasy.IArgumentConstraintManager{``0})">
-            <summary>
-            Constrains an argument so that it must be null (Nothing in VB).
-            </summary>
-            <typeparam name="T">The type of the argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Contains(FakeItEasy.IArgumentConstraintManager{System.String},System.String)">
-            <summary>
-            Constrains the string argument to contain the specified text.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The string the argument string should contain.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Contains``1(FakeItEasy.IArgumentConstraintManager{``0},System.Object)">
-            <summary>
-            Constrains the sequence so that it must contain the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the collection should contain.</param>
-            <typeparam name="T">The type of sequence.</typeparam>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.StartsWith(FakeItEasy.IArgumentConstraintManager{System.String},System.String)">
-            <summary>
-            Constrains the string so that it must start with the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the string should start with.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.EndsWith(FakeItEasy.IArgumentConstraintManager{System.String},System.String)">
-            <summary>
-            Constrains the string so that it must end with the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the string should end with.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsNullOrEmpty(FakeItEasy.IArgumentConstraintManager{System.String})">
-            <summary>
-            Constrains the string so that it must be null or empty.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsGreaterThan``1(FakeItEasy.IArgumentConstraintManager{``0},``0)">
-            <summary>
-            Constrains argument value so that it must be greater than the specified value.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value the string should start with.</param>
-            <typeparam name="T">The type of argument to constrain.</typeparam>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsSameSequenceAs``1(FakeItEasy.IArgumentConstraintManager{``0},System.Collections.IEnumerable)">
-            <summary>
-            The tested argument collection should contain the same elements as the
-            as the specified collection.
-            </summary>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The sequence to test against.</param>
-            <typeparam name="T">The type of argument to constrain.</typeparam>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsEmpty``1(FakeItEasy.IArgumentConstraintManager{``0})">
-            <summary>
-            Tests that the IEnumerable contains no items.
-            </summary>
-            <typeparam name="T">The type of argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsEqualTo``1(FakeItEasy.IArgumentConstraintManager{``0},``0)">
-            <summary>
-            Tests that the passed in argument is equal to the specified value.
-            </summary>
-            <typeparam name="T">The type of the argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The value to compare to.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsSameAs``1(FakeItEasy.IArgumentConstraintManager{``0},``0)">
-            <summary>
-            Tests that the passed in argument is the same instance (reference) as the specified value.
-            </summary>
-            <typeparam name="T">The type of the argument.</typeparam>
-            <param name="manager">The constraint manager to match the constraint.</param>
-            <param name="value">The reference to compare to.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.IsInstanceOf``1(FakeItEasy.IArgumentConstraintManager{``0},System.Type)">
-            <summary>
-            Constrains the argument to be of the specified type.
-            </summary>
-            <typeparam name="T">The type of argument in the method signature.</typeparam>
-            <param name="manager">The constraint manager.</param>
-            <param name="type">The type to constrain the argument with.</param>
-            <returns>A dummy value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Matches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Func{``0,System.Boolean},System.String)">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="scope">
-            The constraint manager.
-            </param>
-            <param name="predicate">
-            The predicate that should constrain the argument.
-            </param>
-            <param name="description">
-            A human readable description of the constraint.
-            </param>
-            <typeparam name="T">
-            The type of argument in the method signature.
-            </typeparam>
-            <returns>
-            A dummy argument value.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Matches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Func{``0,System.Boolean},System.String,System.Object[])">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="manager">
-            The constraint manager.
-            </param>
-            <param name="predicate">
-            The predicate that should constrain the argument.
-            </param>
-            <param name="descriptionFormat">
-            A human readable description of the constraint format string.
-            </param>
-            <param name="args">
-            Arguments for the format string.
-            </param>
-            <typeparam name="T">
-            The type of argument in the method signature.
-            </typeparam>
-            <returns>
-            A dummy argument value.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.Matches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Linq.Expressions.Expression{System.Func{``0,System.Boolean}})">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="scope">
-            The constraint manager.
-            </param>
-            <param name="predicate">
-            The predicate that should constrain the argument.
-            </param>
-            <typeparam name="T">
-            The type of argument in the method signature.
-            </typeparam>
-            <returns>
-            A dummy argument value.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentConstraintExtensions.NullCheckedMatches``1(FakeItEasy.IArgumentConstraintManager{``0},System.Func{``0,System.Boolean},System.Action{FakeItEasy.IOutputWriter})">
-            <summary>
-            Constrains the argument to be not null (Nothing in VB) and to match
-            the specified predicate.
-            </summary>
-            <typeparam name="T">The type of the argument to constrain.</typeparam>
-            <param name="manager">The constraint manager.</param>
-            <param name="predicate">The predicate that constrains non null values.</param>
-            <param name="descriptionWriter">An action that writes a description of the constraint
-            to the output.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="T:FakeItEasy.ArgumentValueFormatter`1">
-            <summary>
-            Provides string formatting for arguments of type T when written in call lists.
-            </summary>
-            <typeparam name="T">The type of the arguments which will be formatted by this instance.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.IArgumentValueFormatter">
-            <summary>
-            Provides string formatting for arguments when written in 
-            call lists.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IArgumentValueFormatter.GetArgumentValueAsString(System.Object)">
-            <summary>
-            Gets a string representing the specified argument value.
-            </summary>
-            <param name="argumentValue">The argument value to get as a string.</param>
-            <returns>A string representation of the value.</returns>
-        </member>
-        <member name="P:FakeItEasy.IArgumentValueFormatter.ForType">
-            <summary>
-            Gets the type of arguments this formatter works on.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.IArgumentValueFormatter.Priority">
-            <summary>
-            Gets the priority of the formatter, when two formatters are
-            registered for the same type the one with the highest
-            priority is used.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ArgumentValueFormatter`1.GetArgumentValueAsString(System.Object)">
-            <summary>
-            Gets a string representing the specified argument value.
-            </summary>
-            <param name="argumentValue">The argument value to get as a string.</param>
-            <returns>A string representation of the value.</returns>
-        </member>
-        <member name="M:FakeItEasy.ArgumentValueFormatter`1.GetStringValue(`0)">
-            <summary>
-            Gets a string representing the specified argument value.
-            </summary>
-            <param name="argumentValue">The argument value to get as a string.</param>
-            <returns>A string representation of the value.</returns>
-        </member>
-        <member name="P:FakeItEasy.ArgumentValueFormatter`1.ForType">
-            <summary>
-            Gets the type of arguments this formatter works on.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ArgumentValueFormatter`1.Priority">
-            <summary>
-            Gets the priority of the formatter, when two formatters are
-            registered for the same type the one with the highest
-            priority is used.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.CommonExtensions">
-            <summary>
-            Provides extension methods for the common uses.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.FormatInvariant(System.String,System.Object[])">
-            <summary>
-            Replaces the format item in a specified System.String with the text equivalent
-            of the value of a corresponding System.Object instance in a specified array using
-            invariant culture as <see cref="T:System.IFormatProvider"/>.
-            </summary>
-            <param name="format">A composite format string.</param>
-            <param name="arguments">An <see cref="T:System.Object"/> array containing zero or more objects to format.</param>
-            <returns>The formatted string.</returns>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.Zip``2(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``1})">
-            <summary>
-            Gets an enumerable of tuples where the first value of each tuple is a value
-            from the first collection and the second value of each tuple is the value at the same position
-            from the second collection.
-            </summary>
-            <typeparam name="TFirst">The type of values in the first collection.</typeparam>
-            <typeparam name="TSecond">The type of values in the second collection.</typeparam>
-            <param name="firstCollection">The first of the collections to combine.</param>
-            <param name="secondCollection">The second of the collections to combine.</param>
-            <returns>An enumerable of tuples.</returns>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.ToCollectionString``1(System.Collections.Generic.IEnumerable{``0},System.Func{``0,System.String},System.String)">
-            <summary>
-            Joins the collection to a string.
-            </summary>
-            <typeparam name="T">The type of items in the collection.</typeparam>
-            <param name="items">The items to join.</param>
-            <param name="stringConverter">A function that converts from an item to a string value.</param>
-            <param name="separator">Separator to insert between each item.</param>
-            <returns>A string representation of the collection.</returns>
-        </member>
-        <member name="M:FakeItEasy.CommonExtensions.FirstFromEachKey``2(System.Collections.Generic.IEnumerable{``0},System.Func{``0,``1})">
-            <summary>
-            Gets a dictionary containing the first element from the sequence that has a key specified by the key selector.
-            </summary>
-            <typeparam name="T">The type of items in the sequence.</typeparam>
-            <typeparam name="TKey">The type of the key.</typeparam>
-            <param name="sequence">The sequence.</param>
-            <param name="keySelector">The key selector.</param>
-            <returns>A dictionary.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.BuildableCallRule">
-            <summary>
-            Provides the base for rules that can be built using the FakeConfiguration.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCallRuleWithDescription">
-            <summary>
-            Represents a call rule that has a description of the calls the
-            rule is applicable to.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCallRule">
-            <summary>
-            Allows for intercepting call to a fake object and
-            act upon them.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets whether this interceptor is applicable to the specified
-            call, if true is returned the Apply-method of the interceptor will
-            be called.
-            </summary>
-            <param name="fakeObjectCall">The call to check for applicability.</param>
-            <returns>True if the interceptor is applicable.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallRule.Apply(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies an action to the call, might set a return value or throw
-            an exception.
-            </summary>
-            <param name="fakeObjectCall">The call to apply the interceptor to.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCallRule.NumberOfTimesToCall">
-            <summary>
-            Gets the number of times this call rule is valid, if it's set
-            to null its infinitely valid.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallRuleWithDescription.WriteDescriptionOfValidCall(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a description of calls the rule is applicable to.
-            </summary>
-            <param name="writer">The writer.</param>
-        </member>
-        <member name="M:FakeItEasy.Configuration.BuildableCallRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets if this rule is applicable to the specified call.
-            </summary>
-            <param name="fakeObjectCall">The call to validate.</param>
-            <returns>True if the rule applies to the call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.BuildableCallRule.WriteDescriptionOfValidCall(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a description of calls the rule is applicable to.
-            </summary>
-            <param name="writer">The writer to write the description to.</param>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.Applicator">
-            <summary>
-            Gets or sets an action that is called by the Apply method to apply this
-            rule to a fake object call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.Actions">
-            <summary>
-            Gets a collection of actions that should be invoked when the configured
-            call is made.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.OutAndRefParametersValues">
-            <summary>
-            Gets or sets values to apply to output and reference variables.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.CallBaseMethod">
-            <summary>
-            Gets or sets a value indicating whether the base method of the fake object call should be
-            called when the fake object call is made.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.NumberOfTimesToCall">
-            <summary>
-            Gets or sets the number of times the configured rule should be used.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Configuration.BuildableCallRule.DescriptionOfValidCall">
-            <summary>
-            Gets a description of calls the rule is applicable to.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAnyCallConfigurationWithNoReturnTypeSpecified">
-            <summary>
-            Configuration for any call to a faked object.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IWhereConfiguration`1">
-            <summary>
-            Provides a way to configure predicates for when a call should be applied.
-            </summary>
-            <typeparam name="T">The type of fake object that is going to be configured..</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IWhereConfiguration`1.Where(System.Func{FakeItEasy.Core.IFakeObjectCall,System.Boolean},System.Action{FakeItEasy.IOutputWriter})">
-            <summary>
-            Applies a predicate to constrain which calls will be considered for interception.
-            </summary>
-            <param name="predicate">A predicate for a fake object call.</param>
-            <param name="descriptionWriter">An action that writes a description of the predicate
-            to the output.</param>
-            <returns>The configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IVoidArgumentValidationConfiguration">
-            <summary>
-            Provides configuration methods for methods that does not have a return value and
-            allows the use to specify validations for arguments.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IVoidConfiguration">
-            <summary>
-            Provides configuration methods for methods that does not have a return value.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IExceptionThrowerConfiguration">
-            <summary>
-            Configuration that lets the developer specify that an exception should be
-            thrown by a fake object call.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IHideObjectMembers">
-            <summary>
-            Hides standard Object members to make fluent interfaces
-            easier to read. Found in the source of Autofac: <see cref="!:http://code.google.com/p/autofac/"/>
-            Based on blog post here:
-            <see cref="!:http://www.clariusconsulting.net/blogs/kzu/archive/2008/03/10/58301.aspx"/>
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.ToString">
-            <summary>
-            Hides the ToString-method.
-            </summary>
-            <returns>A string representation of the implementing object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.Equals(System.Object)">
-            <summary>
-            Determines whether the specified <see cref="T:System.Object"/> is equal to this instance.
-            </summary>
-            <param name="o">The <see cref="T:System.Object"/> to compare with this instance.</param>
-            <returns>
-            <c>true</c> if the specified <see cref="T:System.Object"/> is equal to this instance; otherwise, <c>false</c>.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.GetHashCode">
-            <summary>
-            Returns a hash code for this instance.
-            </summary>
-            <returns>
-            A hash code for this instance, suitable for use in hashing algorithms and data structures like a hash table. 
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IHideObjectMembers.GetType">
-            <summary>
-            Gets the type.
-            </summary>
-            <returns>The exact runtime type of the current instance.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IExceptionThrowerConfiguration.Throws(System.Func{FakeItEasy.Core.IFakeObjectCall,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="exceptionFactory">A function that creates the exception to throw.</param>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.ICallbackConfiguration`1">
-            <summary>
-            Configuration for callbacks of fake object calls.
-            </summary>
-            <typeparam name="TInterface">The type of interface to return.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.ICallbackConfiguration`1.Invokes(System.Action{FakeItEasy.Core.IFakeObjectCall})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="action">The action to invoke.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.ICallBaseConfiguration">
-            <summary>
-            Configuration that lets you specify that a fake object call should call it's base method.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.ICallBaseConfiguration.CallsBaseMethod">
-            <summary>
-            When the configured method or methods are called the call
-            will be delegated to the base method of the faked method.
-            </summary>
-            <returns>A configuration object.</returns>
-            <exception cref="T:System.InvalidOperationException">The fake object is of an abstract type or an interface
-            and no base method exists.</exception>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IOutAndRefParametersConfiguration">
-            <summary>
-            Lets the developer configure output values of out and ref parameters.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IOutAndRefParametersConfiguration.AssignsOutAndRefParameters(System.Object[])">
-            <summary>
-            Specifies output values for out and ref parameters. Specify the values in the order
-            the ref and out parameters has in the configured call, any non out and ref parameters are ignored.
-            </summary>
-            <param name="values">The values.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAssertConfiguration">
-            <summary>
-            Allows the developer to assert on a call that's configured.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IAssertConfiguration.MustHaveHappened(FakeItEasy.Repeated)">
-            <summary>
-            Asserts that the configured call has happened the number of times
-            constrained by the repeatConstraint parameter.
-            </summary>
-            <param name="repeatConstraint">A constraint for how many times the call
-            must have happened.</param>
-            <exception cref="T:FakeItEasy.ExpectationException">The call has not been called a number of times
-            that passes the repeat constraint.</exception>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IVoidConfiguration.DoesNothing">
-            <summary>
-            Configures the specified call to do nothing when called.
-            </summary>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IArgumentValidationConfiguration`1">
-            <summary>
-            Provides configurations to validate arguments of a fake object call.
-            </summary>
-            <typeparam name="TInterface">The type of interface to return.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IArgumentValidationConfiguration`1.WhenArgumentsMatch(System.Func{FakeItEasy.ArgumentCollection,System.Boolean})">
-            <summary>
-            Configures the call to be accepted when the specified predicate returns true.
-            </summary>
-            <param name="argumentsPredicate">The argument predicate.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IAnyCallConfigurationWithNoReturnTypeSpecified.WithReturnType``1">
-            <summary>
-            Matches calls that has the return type specified in the generic type parameter.
-            </summary>
-            <typeparam name="TMember">The return type of the members to configure.</typeparam>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.IoC.Module">
-            <summary>
-            Manages registration of a set of components in a DictionaryContainer.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IoC.Module.RegisterDependencies(FakeItEasy.IoC.DictionaryContainer)">
-            <summary>
-            Registers the components of this module.
-            </summary>
-            <param name="container">The container to register components in.</param>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRecordingCallRuleFactory">
-            <summary>
-            A factory that creates instances of the RecordingCallRuleType.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IRecordingCallRuleFactory.Create``1(FakeItEasy.Core.FakeManager,FakeItEasy.Configuration.RecordedCallRule)">
-            <summary>
-            Creates the specified fake object.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-            <param name="fakeObject">The fake object the rule belongs to.</param>
-            <param name="recordedRule">The rule that's being recorded.</param>
-            <returns>A RecordingCallRule instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IStartConfigurationFactory">
-            <summary>
-            A factory responsible for creating start configuration for fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfigurationFactory.CreateConfiguration``1(FakeItEasy.Core.FakeManager)">
-            <summary>
-            Creates a start configuration for the specified fake object that fakes the
-            specified type.
-            </summary>
-            <typeparam name="TFake">The type of the fake object.</typeparam>
-            <param name="fakeObject">The fake object to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.FakeConfigurationException">
-            <summary>
-            An exception that can be thrown when something goes wrong with the configuration
-            of a fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.Configuration.FakeConfigurationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Configuration.FakeConfigurationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IFakeConfigurationManager">
-            <summary>
-            Handles the configuration of fake object given an expression specifying
-            a call on a faked object.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAfterCallSpecifiedConfiguration">
-            <summary>
-            Lets you set up expectations and configure repeat for the configured call.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRepeatConfiguration">
-            <summary>
-            Provides configuration for method calls that has a return value.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IRepeatConfiguration.NumberOfTimes(System.Int32)">
-            <summary>
-            Specifies the number of times for the configured event.
-            </summary>
-            <param name="numberOfTimesToRepeat">The number of times to repeat.</param>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAfterCallSpecifiedWithOutAndRefParametersConfiguration">
-            <summary>
-            A combination of the IAfterCallSpecifiedConfiguration and IOutAndRefParametersConfiguration
-            interfaces.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IAnyCallConfigurationWithReturnTypeSpecified`1">
-            <summary>
-            Aggregate of IReturnValueArgumentValidationConfiguration&lt;T&gt; and IWhereConfiguration&lt;IAnyCallConfigurationWithReturnTypeSpecified&lt;T&gt;&gt;.
-            </summary>
-            <typeparam name="T">The type of fake object that is configured.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IReturnValueArgumentValidationConfiguration`1">
-            <summary>
-            Configures a call that returns a value and allows the use to
-            specify validations for arguments.
-            </summary>
-            <typeparam name="TMember">The type of the member.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IReturnValueConfiguration`1">
-            <summary>
-            Configures a call that returns a value.
-            </summary>
-            <typeparam name="TMember">The type of the member.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IReturnValueConfiguration`1.ReturnsLazily(System.Func{FakeItEasy.Core.IFakeObjectCall,`0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRecordingConfiguration">
-            <summary>
-            Configurations for when a configured call is recorded.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IRecordingConfigurationWithArgumentValidation">
-            <summary>
-            Provides configuration from VisualBasic.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.IStartConfiguration`1">
-            <summary>
-            Provides methods for configuring a fake object.
-            </summary>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfiguration`1.CallsTo``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <typeparam name="TMember">The type of the return value of the member.</typeparam>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfiguration`1.CallsTo(System.Linq.Expressions.Expression{System.Action{`0}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Configuration.IStartConfiguration`1.AnyCall">
-            <summary>
-            Configures the behavior of the fake object when a call is made to any method on the
-            object.
-            </summary>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configuration.RecordedCallRule">
-            <summary>
-            A call rule that has been recorded.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.RecordingCallRule`1">
-            <summary>
-            A call rule that "sits and waits" for the next call, when
-            that call occurs the recorded rule is added for that call.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Core.ICallCollectionAndCallMatcherAccessor">
-            <summary>
-            Provides access to a set of calls and a call matcher for these calls.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ICallMatcherAccessor">
-            <summary>
-            Provides access to a call matcher.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ICallMatcherAccessor.Matcher">
-            <summary>
-            Gets a call predicate that can be used to check if a fake object call matches
-            the specified constraint.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ICallCollectionAndCallMatcherAccessor.Calls">
-            <summary>
-            Gets the set of calls.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Configuration.RuleBuilder.Factory">
-            <summary>
-            Represents a delegate that creates a configuration object from
-            a fake object and the rule to build.
-            </summary>
-            <param name="ruleBeingBuilt">The rule that's being built.</param>
-            <param name="fakeObject">The fake object the rule is for.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.ICallMatcher">
-            <summary>
-            Represents a predicate that matches a fake object call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ICallMatcher.Matches(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets a value indicating whether the call matches the predicate.
-            </summary>
-            <param name="fakeObjectCall">The call to match.</param>
-            <returns>True if the call matches the predicate.</returns>
-        </member>
-        <member name="T:FakeItEasy.Configure">
-            <summary>
-            Provides configuration of faked objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Configure.Fake``1(``0)">
-            <summary>
-            Gets a configuration for the specified faked object.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-            <param name="fakedObject">The faked object to configure.</param>
-            <returns>A configuration object.</returns>
-            <exception cref="T:System.ArgumentException">The specified object is not a faked object.</exception>
-            <exception cref="T:System.ArgumentNullException">The fakedObject parameter was null.</exception>
-        </member>
-        <member name="T:FakeItEasy.Core.ArgumentInfo">
-            <summary>
-            Represents an argument and a dummy value to use for that argument.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.ArgumentInfo.#ctor(System.Boolean,System.Type,System.Object)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.ArgumentInfo"/> class.
-            </summary>
-            <param name="wasSuccessfullyResolved">A value indicating if the dummy value was successfully resolved.</param>
-            <param name="typeOfArgument">The type of argument.</param>
-            <param name="resolvedValue">The resolved value.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.ArgumentInfo.WasSuccessfullyResolved">
-            <summary>
-            Gets a value indicating whether a dummy argument value was successfully
-            resolved.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ArgumentInfo.TypeOfArgument">
-            <summary>
-            Gets the type of the argument.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ArgumentInfo.ResolvedValue">
-            <summary>
-            Gets the resolved value.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.ArgumentValueFormatter.RangedFormatter">
-            <summary>
-            Holds a formatter as well as the distance between a type to be formatted
-            and the type for which the formatted is registered.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.CallInterceptedEventArgs">
-            <summary>
-            Represents an event that happens when a call has been intercepted by a proxy.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.CallInterceptedEventArgs.#ctor(FakeItEasy.Core.IWritableFakeObjectCall)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.CallInterceptedEventArgs"/> class.
-            </summary>
-            <param name="call">The call.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.CallInterceptedEventArgs.Call">
-            <summary>
-            Gets the call that was intercepted.
-            </summary>
-            <value>The call.</value>
-        </member>
-        <member name="T:FakeItEasy.Core.CallRuleMetadata">
-            <summary>
-            Keeps track of metadata for interceptions.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.CallRuleMetadata.HasNotBeenCalledSpecifiedNumberOfTimes">
-            <summary>
-            Gets whether the rule has been called the number of times specified or not.
-            </summary>
-            <returns>True if the rule has not been called the number of times specified.</returns>
-        </member>
-        <member name="P:FakeItEasy.Core.CallRuleMetadata.CalledNumberOfTimes">
-            <summary>
-            Gets or sets the number of times the rule has been used.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.CallRuleMetadata.Rule">
-            <summary>
-            Gets or sets the rule this metadata object is tracking.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.IArgumentConstraintManager`1">
-            <summary>
-            Manages attaching of argument constraints.
-            </summary>
-            <typeparam name="T">The type of argument to constrain.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.IArgumentConstraintManager`1.Matches(System.Func{`0,System.Boolean},System.Action{FakeItEasy.IOutputWriter})">
-            <summary>
-            Constrains the argument with a predicate.
-            </summary>
-            <param name="predicate">The predicate that should constrain the argument.</param>
-            <param name="descriptionWriter">An action that will be write a description of the constraint.</param>
-            <returns>A dummy argument value.</returns>
-        </member>
-        <member name="P:FakeItEasy.IArgumentConstraintManager`1.Not">
-            <summary>
-            Inverts the logic of the matches method.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IArgumentConstraint">
-            <summary>
-            Validates an argument, checks that it's valid in a specific fake call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IArgumentConstraint.WriteDescription(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a description of the argument constraint to the specified writer.
-            </summary>
-            <param name="writer">
-            The writer.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Core.IArgumentConstraint.IsValid(System.Object)">
-            <summary>
-            Gets whether the argument is valid.
-            </summary>
-            <param name="argument">The argument to validate.</param>
-            <returns>True if the argument is valid.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.DefaultFakeManagerAccessor">
-            <summary>
-            Default implementation of <see cref="T:FakeItEasy.Core.IFakeManagerAccessor"/>.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeManagerAccessor">
-            <summary>
-            Attaches a fake manager to the proxy so that intercepted
-            calls can be configured.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeManagerAccessor.AttachFakeManagerToProxy(System.Type,System.Object,FakeItEasy.Creation.ICallInterceptedEventRaiser)">
-            <summary>
-            Attaches a <see cref="T:FakeItEasy.Core.FakeManager"/> to the specified proxy, listening to
-            the event raiser.
-            </summary>
-            <param name="typeOfFake">The type of the fake object proxy.</param>
-            <param name="proxy">The proxy to attach to.</param>
-            <param name="eventRaiser">The event raiser to listen to.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeManagerAccessor.GetFakeManager(System.Object)">
-            <summary>
-            Gets the fake manager associated with the proxy.
-            </summary>
-            <param name="proxy">The proxy to get the manager from.</param>
-            <returns>A fake manager.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeManagerAccessor.AttachFakeManagerToProxy(System.Type,System.Object,FakeItEasy.Creation.ICallInterceptedEventRaiser)">
-            <summary>
-            Attaches a <see cref="T:FakeItEasy.Core.FakeManager"/> to the specified proxy, listening to
-            the event raiser.
-            </summary>
-            <param name="typeOfFake">The type of the fake object proxy.</param>
-            <param name="proxy">The proxy to attach to.</param>
-            <param name="eventRaiser">The event raiser to listen to.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeManagerAccessor.GetFakeManager(System.Object)">
-            <summary>
-            Gets the fake manager associated with the proxy.
-            </summary>
-            <param name="proxy">The proxy to get the manager from.</param>
-            <returns>A fake manager.</returns>
-        </member>
-        <member name="T:FakeItEasy.Creation.ITaggable">
-            <summary>
-            Represents an object that can be tagged with another object. When implemented
-            by a proxy returned from an <see cref="T:FakeItEasy.Creation.IProxyGenerator"/> FakeItEasy uses the tag
-            to store a reference to the <see cref="T:FakeItEasy.Core.FakeManager"/> that handles that proxy.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ITaggable.Tag">
-            <summary>
-            Gets or sets the tag.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.DefaultFakeObjectCallFormatter">
-            <summary>
-            The default implementation of the IFakeObjectCallFormatter interface.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCallFormatter">
-            <summary>
-            Provides string formatting for fake object calls.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectCallFormatter.GetDescription(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets a human readable description of the specified
-            fake object call.
-            </summary>
-            <param name="call">The call to get a description for.</param>
-            <returns>A description of the call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeObjectCallFormatter.GetDescription(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets a human readable description of the specified
-            fake object call.
-            </summary>
-            <param name="call">The call to get a description for.</param>
-            <returns>A description of the call.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.DefaultFakeWrapperConfigurer">
-            <summary>
-            Handles configuring of fake objects to delegate all their calls to a wrapped instance.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeWrapperConfigurer">
-            <summary>
-            Manages configuration of fake objects to wrap instances.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeWrapperConfigurer.ConfigureFakeToWrap(System.Object,System.Object,FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Configures the specified faked object to wrap the specified instance.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <param name="wrappedInstance">The instance to wrap.</param>
-            <param name="recorder">The recorder to use, null if no recording should be made.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DefaultFakeWrapperConfigurer.ConfigureFakeToWrap(System.Object,System.Object,FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Configures the specified faked object to wrap the specified instance.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <param name="wrappedInstance">The instance to wrap.</param>
-            <param name="recorder">The recorder to use, null if no recording should be made.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.DelegateFakeObjectContainer">
-            <summary>
-            A fake object container where delegates can be registered that are used to
-            resolve fake objects.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectContainer">
-            <summary>
-            A container that can create fake objects.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectConfigurator">
-            <summary>
-            Handles global configuration of fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectConfigurator.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Applies base configuration to a fake object.
-            </summary>
-            <param name="typeOfFake">The type the fake object represents.</param>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IFakeObjectContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Creates a dummy object of the specified type using the specified arguments if it's
-            supported by the container, returns a value indicating if it's supported or not.
-            </summary>
-            <param name="typeOfDummy">The type of dummy object to create.</param>
-            <param name="fakeObject">The dummy object that was created if the method returns true.</param>
-            <returns>True if a dummy object can be created.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.DelegateFakeObjectContainer"/> class. 
-            Creates a new instance of the DelegateFakeObjectContainer.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Creates a fake object of the specified type using the specified arguments if it's
-            supported by the container, returns a value indicating if it's supported or not.
-            </summary>
-            <param name="typeOfDummy">The type of dummy object to create.</param>
-            <param name="fakeObject">The fake object that was created if the method returns true.</param>
-            <returns>True if a fake object can be created.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Configures the fake.
-            </summary>
-            <param name="typeOfFake">The type of fake.</param>
-            <param name="fakeObject">The fake object.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DelegateFakeObjectContainer.Register``1(System.Func{``0})">
-            <summary>
-            Registers the specified fake delegate.
-            </summary>
-            <typeparam name="T">The type of the return value of the method that <paramref name="fakeDelegate"/> encapsulates.</typeparam>
-            <param name="fakeDelegate">The fake delegate.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.DynamicContainer">
-            <summary>
-            A IFakeObjectContainer implementation that uses MEF to load IFakeDefinitions and
-            IFakeConfigurations.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.DynamicContainer.#ctor(System.Collections.Generic.IEnumerable{FakeItEasy.IDummyDefinition},System.Collections.Generic.IEnumerable{FakeItEasy.IFakeConfigurator})">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.DynamicContainer"/> class.
-            </summary>
-            <param name="dummyDefinitions">The dummy definitions.</param>
-            <param name="fakeConfigurators">The fake configurators.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.DynamicContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Creates a fake object of the specified type using the specified arguments if it's
-            supported by the container, returns a value indicating if it's supported or not.
-            </summary>
-            <param name="typeOfDummy">The type of fake object to create.</param>
-            <param name="fakeObject">The fake object that was created if the method returns true.</param>
-            <returns>True if a fake object can be created.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.DynamicContainer.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Applies base configuration to a fake object.
-            </summary>
-            <param name="typeOfFake">The type the fake object represents.</param>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeCreationException">
-            <summary>
-            An exception that is thrown when there was an error creating a fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeCreationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeCreationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeManager">
-            <content>Auto fake property rule.</content>
-            <summary>
-            The central point in the API for proxied fake objects handles interception
-            of fake object calls by using a set of rules. User defined rules can be inserted
-            by using the AddRule-method.
-            </summary>
-            <content>Event rule.</content>
-            <content>Object member rule.</content>
-            <content>Property behavior rule.</content>
-            <content>Property setter rule.</content>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.FakeManager"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.AddRuleFirst(FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Adds a call rule to the fake object.
-            </summary>
-            <param name="rule">The rule to add.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.AddRuleLast(FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Adds a call rule last in the list of user rules, meaning it has the lowest priority possible.
-            </summary>
-            <param name="rule">The rule to add.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.RemoveRule(FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Removes the specified rule for the fake object.
-            </summary>
-            <param name="rule">The rule to remove.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.AddInterceptionListener(FakeItEasy.Core.IInterceptionListener)">
-            <summary>
-            Adds an interception listener to the manager.
-            </summary>
-            <param name="listener">The listener to add.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeManager.ClearUserRules">
-            <summary>
-            Removes any specified user rules.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.Object">
-            <summary>
-            Gets the faked object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.FakeObjectType">
-            <summary>
-            Gets the faked type.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.Rules">
-            <summary>
-            Gets the interceptions that are currently registered with the fake object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.FakeManager.RecordedCallsInScope">
-            <summary>
-            Gets a collection of all the calls made to the fake object within the current scope.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeManager.Factory">
-            <summary>
-            A delegate responsible for creating FakeObject instances.
-            </summary>
-            <returns>An instance of <see cref="T:FakeItEasy.Core.FakeManager"/>.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.IInterceptedFakeObjectCall">
-            <summary>
-            Represents a call to a fake object at interception time.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IWritableFakeObjectCall">
-            <summary>
-            Represents a fake object call that can be edited.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeObjectCall">
-            <summary>
-            Represents a call to a fake object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCall.Method">
-            <summary>
-            Gets the method that's called.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCall.Arguments">
-            <summary>
-            Gets the arguments used in the call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IFakeObjectCall.FakedObject">
-            <summary>
-            Gets the faked object the call is performed on.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.SetReturnValue(System.Object)">
-            <summary>
-            Sets the return value of the call.
-            </summary>
-            <param name="value">The return value to set.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.CallBaseMethod">
-            <summary>
-            Calls the base method of the faked type.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.SetArgumentValue(System.Int32,System.Object)">
-            <summary>
-            Sets the value of the argument at the specified index in the parameters list.
-            </summary>
-            <param name="index">The index of the argument to set the value of.</param>
-            <param name="value">The value to set to the argument.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IWritableFakeObjectCall.AsReadOnly">
-            <summary>
-            Freezes the call so that it can no longer be modified.
-            </summary>
-            <returns>A completed fake object call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.IInterceptedFakeObjectCall.DoNotRecordCall">
-            <summary>
-            Sets that the call should not be recorded by the fake manager.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.FakeScope">
-            <summary>
-            Represents a scope for fake objects, calls configured within a scope
-            are only valid within that scope. Only calls made within a scope
-            are accessible from within a scope so for example asserts will only
-            assert on those calls done within the scope.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IFakeScope">
-            <summary>
-            Provides access to all calls made to fake objects within a scope.
-            Scopes calls so that only calls made within the scope are visible.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.Create">
-            <summary>
-            Creates a new scope and sets it as the current scope.
-            </summary>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.Create(FakeItEasy.Core.IFakeObjectContainer)">
-            <summary>
-            Creates a new scope and sets it as the current scope, using the specified
-            container as the container for the new scope.
-            </summary>
-            <param name="container">The container to use for the new scope.</param>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.Dispose">
-            <summary>
-            Closes the scope.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.AddInterceptedCall(FakeItEasy.Core.FakeManager,FakeItEasy.Core.ICompletedFakeObjectCall)">
-            <summary>
-            Adds an intercepted call to the current scope.
-            </summary>
-            <param name="fakeManager">The fake object.</param>
-            <param name="call">The call that is intercepted.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.FakeScope.AddRuleFirst(FakeItEasy.Core.FakeManager,FakeItEasy.Core.CallRuleMetadata)">
-            <summary>
-            Adds a fake object call to the current scope.
-            </summary>
-            <param name="fakeManager">The fake object.</param>
-            <param name="rule">The rule to add.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.ICompletedFakeObjectCall">
-            <summary>
-            Represents a completed call to a fake object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.ICompletedFakeObjectCall.ReturnValue">
-            <summary>
-            Gets the value set to be returned from the call.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IEventRaiserArguments">
-            <summary>
-            Used by the event raising rule of fake objects to get the event arguments used in
-            a call to Raise.With.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IEventRaiserArguments.Sender">
-            <summary>
-            Gets the sender of the event.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Core.IEventRaiserArguments.EventArguments">
-            <summary>
-            Gets the event arguments of the event.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Core.IInterceptionListener">
-            <summary>
-            Represents a listener for fake object calls, can be plugged into a
-            FakeManager instance to listen to all intercepted calls.
-            </summary>
-            <remarks>The OnBeforeCallIntercepted method will be invoked before the OnBeforeCallIntercepted method of any
-            previously added listener. The OnAfterCallIntercepted method will be invoked after the OnAfterCallIntercepted
-            method of any previously added listener.</remarks>
-        </member>
-        <member name="M:FakeItEasy.Core.IInterceptionListener.OnBeforeCallIntercepted(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Called when the interception begins but before any call rules
-            has been applied.
-            </summary>
-            <param name="interceptedCall">The intercepted call.</param>
-        </member>
-        <member name="M:FakeItEasy.Core.IInterceptionListener.OnAfterCallIntercepted(FakeItEasy.Core.ICompletedFakeObjectCall,FakeItEasy.Core.IFakeObjectCallRule)">
-            <summary>
-            Called when the interception has been completed and rules has been
-            applied.
-            </summary>
-            <param name="interceptedCall">The intercepted call.</param>
-            <param name="ruleThatWasApplied">The rule that was applied to the call.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.MethodInfoManager">
-            <summary>
-            Handles comparisons of instances of <see cref="T:System.Reflection.MethodInfo"/>.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.MethodInfoManager.WillInvokeSameMethodOnTarget(System.Type,System.Reflection.MethodInfo,System.Reflection.MethodInfo)">
-            <summary>
-            Gets a value indicating whether the two instances of <see cref="T:System.Reflection.MethodInfo"/> would invoke the same method
-            if invoked on an instance of the target type.
-            </summary>
-            <param name="target">The type of target for invocation.</param>
-            <param name="first">The first <see cref="T:System.Reflection.MethodInfo"/>.</param>
-            <param name="second">The second <see cref="T:System.Reflection.MethodInfo"/>.</param>
-            <returns>True if the same method would be invoked.</returns>
-        </member>
-        <member name="T:FakeItEasy.Core.NullFakeObjectContainer">
-            <summary>
-            A null implementation for the IFakeObjectContainer interface.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.NullFakeObjectContainer.TryCreateDummyObject(System.Type,System.Object@)">
-            <summary>
-            Always returns false and sets the fakeObject to null.
-            </summary>
-            <param name="typeOfDummy">The type of dummy object to create.</param>
-            <param name="fakeObject">Output variable for the fake object that will always be set to null.</param>
-            <returns>Always return false.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.NullFakeObjectContainer.ConfigureFake(System.Type,System.Object)">
-            <summary>
-            Applies base configuration to a fake object.
-            </summary>
-            <param name="typeOfFake">The type the fake object represents.</param>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="T:FakeItEasy.Core.WrappedObjectRule">
-            <summary>
-            A call rule that applies to any call and just delegates the
-            call to the wrapped object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Core.WrappedObjectRule.#ctor(System.Object)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Core.WrappedObjectRule"/> class. 
-            Creates a new instance.
-            </summary>
-            <param name="wrappedInstance">
-            The object to wrap.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Core.WrappedObjectRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets whether this interceptor is applicable to the specified
-            call, if true is returned the Apply-method of the interceptor will
-            be called.
-            </summary>
-            <param name="fakeObjectCall">The call to check for applicability.</param>
-            <returns>True if the interceptor is applicable.</returns>
-        </member>
-        <member name="M:FakeItEasy.Core.WrappedObjectRule.Apply(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies an action to the call, might set a return value or throw
-            an exception.
-            </summary>
-            <param name="fakeObjectCall">The call to apply the interceptor to.</param>
-        </member>
-        <member name="P:FakeItEasy.Core.WrappedObjectRule.NumberOfTimesToCall">
-            <summary>
-            Gets the number of times this call rule is valid, if it's set
-            to null its infinitely valid.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.Creation.IProxyGenerator">
-            <summary>
-            An interface to be implemented by classes that can generate proxies for FakeItEasy.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.IProxyGenerator.GenerateProxy(System.Type,System.Collections.Generic.IEnumerable{System.Type},System.Collections.Generic.IEnumerable{System.Object},System.Collections.Generic.IEnumerable{System.Reflection.Emit.CustomAttributeBuilder})">
-            <summary>
-            Generates a proxy of the specified type and returns a result object containing information
-            about the success of the generation and the proxy if it was generated.
-            </summary>
-            <param name="typeOfProxy">The type of proxy to generate.</param>
-            <param name="additionalInterfacesToImplement">Interfaces to be implemented by the proxy.</param>
-            <param name="argumentsForConstructor">Arguments to pass to the constructor of the type in <paramref name="typeOfProxy" />.</param>
-            <param name="customAttributeBuilders">The custom attribute builders.</param>
-            <returns>A result containing the generated proxy.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IProxyGenerator.GenerateProxy(System.Type,System.Collections.Generic.IEnumerable{System.Type},System.Collections.Generic.IEnumerable{System.Object})">
-            <summary>
-            Generates a proxy of the specified type and returns a result object containing information
-            about the success of the generation and the proxy if it was generated.
-            </summary>
-            <param name="typeOfProxy">The type of proxy to generate.</param>
-            <param name="additionalInterfacesToImplement">Interfaces to be implemented by the proxy.</param>
-            <param name="argumentsForConstructor">Arguments to pass to the constructor of the type in <paramref name="typeOfProxy" />.</param>
-            <returns>A result containing the generated proxy.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IProxyGenerator.MethodCanBeInterceptedOnInstance(System.Reflection.MethodInfo,System.Object,System.String@)">
-            <summary>
-            Gets a value indicating whether the specified member can be intercepted by the proxy generator.
-            </summary>
-            <param name="method">The member to test.</param>
-            <param name="callTarget">The instance the method will be called on.</param>
-            <param name="failReason">The reason the method can not be intercepted.</param>
-            <returns>True if the member can be intercepted.</returns>
-        </member>
-        <member name="T:FakeItEasy.Creation.ICallInterceptedEventRaiser">
-            <summary>
-            An object that raises an event every time a call to a proxy has been intercepted.
-            </summary>
-        </member>
-        <member name="E:FakeItEasy.Creation.ICallInterceptedEventRaiser.CallWasIntercepted">
-            <summary>
-            Raised when a call is intercepted.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter">
-            <summary>
-            An adapter that adapts an <see cref="T:Castle.DynamicProxy.IInvocation"/> to a <see cref="T:FakeItEasy.Core.IFakeObjectCall"/>.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.#ctor(Castle.DynamicProxy.IInvocation)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter"/> class.
-            </summary>
-            <param name="invocation">The invocation.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.AsReadOnly">
-            <summary>
-            Freezes the call so that it can no longer be modified.
-            </summary>
-            <returns>A completed fake object call.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.CallBaseMethod">
-            <summary>
-            Calls the base method, should not be used with interface types.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.SetArgumentValue(System.Int32,System.Object)">
-            <summary>
-            Sets the specified value to the argument at the specified index.
-            </summary>
-            <param name="index">The index of the argument to set the value to.</param>
-            <param name="value">The value to set to the argument.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.SetReturnValue(System.Object)">
-            <summary>
-            Sets the return value of the call.
-            </summary>
-            <param name="returnValue">The return value.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.ToString">
-            <summary>
-            Returns a description of the call.
-            </summary>
-            <returns>
-            A <see cref="T:System.String"/> that represents this instance.
-            </returns>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.Description">
-            <summary>
-            Gets a human readable description of the call.
-            </summary>
-            <value></value>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.ReturnValue">
-            <summary>
-            Gets the value set to be returned from the call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.Method">
-            <summary>
-            Gets the method that's called.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.Arguments">
-            <summary>
-            Gets the arguments used in the call.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.CastleInvocationCallAdapter.FakedObject">
-            <summary>
-            Gets the faked object the call is performed on.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources">
-            <summary>
-              A strongly-typed resource class, for looking up localized strings, etc.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ResourceManager">
-            <summary>
-              Returns the cached ResourceManager instance used by this class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.Culture">
-            <summary>
-              Overrides the current thread's CurrentUICulture property for all
-              resource lookups using this strongly typed resource class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ArgumentsForConstructorDoesNotMatchAnyConstructorMessage">
-            <summary>
-              Looks up a localized string similar to No constructor matches the passed arguments for constructor..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ArgumentsForConstructorOnInterfaceTypeMessage">
-            <summary>
-              Looks up a localized string similar to Arguments for constructor specified for interface type..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ProxyIsSealedTypeMessage">
-            <summary>
-              Looks up a localized string similar to The type of proxy &quot;{0}&quot; is sealed..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ProxyIsValueTypeMessage">
-            <summary>
-              Looks up a localized string similar to The type of proxy must be an interface or a class but it was {0}..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.CastleDynamicProxy.DynamicProxyResources.ProxyTypeWithNoDefaultConstructorMessage">
-            <summary>
-              Looks up a localized string similar to No usable default constructor was found on the type {0}..
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.DefaultFakeAndDummyManager">
-            <summary>
-            The default implementation of the IFakeAndDummyManager interface.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeAndDummyManager">
-            <summary>
-            Handles the creation of fake and dummy objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.CreateDummy(System.Type)">
-            <summary>
-            Creates a dummy of the specified type.
-            </summary>
-            <param name="typeOfDummy">The type of dummy to create.</param>
-            <returns>The created dummy.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">The current IProxyGenerator is not able to generate a fake of the specified type and
-            the current IFakeObjectContainer does not contain the specified type.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.CreateFake(System.Type,FakeItEasy.Creation.FakeOptions)">
-            <summary>
-            Creates a fake object of the specified type.
-            </summary>
-            <param name="typeOfFake">The type of fake object to generate.</param>
-            <param name="options">Options for building the fake object.</param>
-            <returns>A fake object.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">The current IProxyGenerator is not able to generate a fake of the specified type.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.TryCreateDummy(System.Type,System.Object@)">
-            <summary>
-            Tries to create a dummy of the specified type.
-            </summary>
-            <param name="typeOfDummy">The type of dummy to create.</param>
-            <param name="result">Outputs the result dummy when creation is successful.</param>
-            <returns>A value indicating whether the creation was successful.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeAndDummyManager.TryCreateFake(System.Type,FakeItEasy.Creation.FakeOptions,System.Object@)">
-            <summary>
-            Tries to create a fake object of the specified type.
-            </summary>
-            <param name="typeOfFake">The type of fake to create.</param>
-            <param name="options">Options for the creation of the fake.</param>
-            <param name="result">The created fake object when creation is successful.</param>
-            <returns>A value indicating whether the creation was successful.</returns>
-        </member>
-        <member name="T:FakeItEasy.Creation.DefaultFakeCreatorFacade">
-            <summary>
-            Default implementation of the IFakeCreator-interface.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeCreatorFacade">
-            <summary>
-            A facade used by the public API for testability.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeCreatorFacade.CreateFake``1(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{``0}})">
-            <summary>
-            Creates a fake object of the specified type.
-            </summary>
-            <typeparam name="T">The type of fake to create.</typeparam>
-            <param name="options">Options for the created fake object.</param>
-            <returns>The created fake object.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeCreatorFacade.CreateDummy``1">
-            <summary>
-            Creates a dummy object, this can be a fake object or an object resolved
-            from the current IFakeObjectContainer.
-            </summary>
-            <typeparam name="T">The type of dummy to create.</typeparam>
-            <returns>The created dummy.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration and
-            no dummy was registered in the container for the specified type..</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeCreatorFacade.CollectionOfFake``1(System.Int32)">
-            <summary>
-            Creates a collection of fakes of the specified type.
-            </summary>
-            <typeparam name="T">The type of fakes to create.</typeparam>
-            <param name="numberOfFakes">The number of fakes in the collection.</param>
-            <returns>A collection of fake objects of the specified type.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.#ctor(FakeItEasy.Creation.IFakeAndDummyManager)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.DefaultFakeCreatorFacade"/> class.
-            </summary>
-            <param name="fakeAndDummyManager">The fake and dummy manager.</param>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.CreateFake``1(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{``0}})">
-            <summary>
-            Creates a fake object of the specified type.
-            </summary>
-            <typeparam name="T">The type of fake to create.</typeparam>
-            <param name="options">Options for the created fake object.</param>
-            <returns>The created fake object.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.CollectionOfFake``1(System.Int32)">
-            <summary>
-            Creates a collection of fakes of the specified type.
-            </summary>
-            <typeparam name="T">The type of fakes to create.</typeparam>
-            <param name="numberOfFakes">The number of fakes in the collection.</param>
-            <returns>
-            A collection of fake objects of the specified type.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.DefaultFakeCreatorFacade.CreateDummy``1">
-            <summary>
-            Creates a dummy object, this can be a fake object or an object resolved
-            from the current IFakeObjectContainer.
-            </summary>
-            <typeparam name="T">The type of dummy to create.</typeparam>
-            <returns>The created dummy.</returns>
-            <exception cref="T:FakeItEasy.Core.FakeCreationException">Was unable to generate the fake in the current configuration and
-            no dummy was registered in the container for the specified type..</exception>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeOptionsBuilderForWrappers`1">
-            <summary>
-            Provides options for fake wrappers.
-            </summary>
-            <typeparam name="T">The type of the fake object generated.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.Creation.IFakeOptionsBuilder`1">
-            <summary>
-            Provides options for generating fake object.
-            </summary>
-            <typeparam name="T">The type of fake object generated.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.WithArgumentsForConstructor(System.Collections.Generic.IEnumerable{System.Object})">
-            <summary>
-            Specifies arguments for the constructor of the faked class.
-            </summary>
-            <param name="argumentsForConstructor">The arguments to pass to the constructor of the faked class.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.WithArgumentsForConstructor(System.Linq.Expressions.Expression{System.Func{`0}})">
-            <summary>
-            Specifies arguments for the constructor of the faked class by giving an expression with the call to
-            the desired constructor using the arguments to be passed to the constructor.
-            </summary>
-            <param name="constructorCall">The constructor call to use when creating a class proxy.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.Wrapping(`0)">
-            <summary>
-            Specifies that the fake should delegate calls to the specified instance.
-            </summary>
-            <param name="wrappedInstance">The object to delegate calls to.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.WithAdditionalAttributes(System.Collections.Generic.IEnumerable{System.Reflection.Emit.CustomAttributeBuilder})">
-            <summary>
-            Specifies that the fake should be created with these additional attributes.
-            </summary>
-            <param name="customAttributeBuilders">The attributes to build into the proxy.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.Implements(System.Type)">
-            <summary>
-            Sets up the fake to implement the specified interface in addition to the
-            originally faked class.
-            </summary>
-            <param name="interfaceType">The type of interface to implement.</param>
-            <returns>Options object.</returns>
-            <exception cref="T:System.ArgumentException">The specified type is not an interface.</exception>
-            <exception cref="T:System.ArgumentNullException">The specified type is null.</exception>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilder`1.OnFakeCreated(System.Action{`0})">
-            <summary>
-            Specifies an action that should be run over the fake object
-            once it's created.
-            </summary>
-            <param name="action">An action to perform.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.IFakeOptionsBuilderForWrappers`1.RecordedBy(FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Specifies a fake recorder to use.
-            </summary>
-            <param name="recorder">The recorder to use.</param>
-            <returns>Options object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Creation.DummyValueCreationSession.#ctor(FakeItEasy.Core.IFakeObjectContainer,FakeItEasy.Creation.IFakeObjectCreator)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.DummyValueCreationSession"/> class.
-            </summary>
-            <param name="container">The container.</param>
-            <param name="fakeObjectCreator">The fake object creator.</param>
-        </member>
-        <member name="T:FakeItEasy.Creation.ProxyGeneratorResult">
-            <summary>
-            Contains the result of a call to TryCreateProxy of IProxyGenerator.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Creation.ProxyGeneratorResult.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.ProxyGeneratorResult"/> class. 
-            Creates a new instance representing a failed proxy
-            generation attempt.
-            </summary>
-            <param name="reasonForFailure">
-            The reason the proxy generation failed.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Creation.ProxyGeneratorResult.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.ProxyGeneratorResult"/> class. 
-            Creates a new instance representing a failed proxy
-            generation attempt due to an exception being caught.
-            </summary>
-            <param name="reasonForFailure">
-            The reason the proxy generation failed.
-            </param>
-            <param name="exception">
-            The exception thrown from the creation attempt.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Creation.ProxyGeneratorResult.#ctor(System.Object,FakeItEasy.Creation.ICallInterceptedEventRaiser)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Creation.ProxyGeneratorResult"/> class. 
-            Creates a new instance representing a successful proxy
-            generation.
-            </summary>
-            <param name="generatedProxy">
-            The proxy that was generated.
-            </param>
-            <param name="callInterceptedEventRaiser">
-            An event raiser that raises
-            events when calls are intercepted to the proxy.
-            </param>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.ProxyWasSuccessfullyGenerated">
-            <summary>
-            Gets a value indicating whether the proxy was successfully created.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.GeneratedProxy">
-            <summary>
-            Gets the generated proxy when it was successfully created.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.CallInterceptedEventRaiser">
-            <summary>
-            Gets the event raiser that raises events when calls to the proxy are
-            intercepted.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Creation.ProxyGeneratorResult.ReasonForFailure">
-            <summary>
-            Gets the reason for failure when the generation was not successful.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.IOutputWriter">
-            <summary>
-            Represents a text writer that writes to the output.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IOutputWriter.Write(System.String)">
-            <summary>
-            Writes the specified value to the output.
-            </summary>
-            <param name="value">The value to write.</param>
-            <returns>The writer for method chaining.</returns>
-        </member>
-        <member name="M:FakeItEasy.IOutputWriter.WriteArgumentValue(System.Object)">
-            <summary>
-            Formats the specified argument value as a string and writes
-            it to the output.
-            </summary>
-            <param name="value">The value to write.</param>
-            <returns>The writer for method chaining.</returns>
-        </member>
-        <member name="M:FakeItEasy.IOutputWriter.Indent">
-            <summary>
-            Indents the writer.
-            </summary>
-            <returns>A disposable that will unindent the writer when disposed.</returns>
-        </member>
-        <member name="T:FakeItEasy.DummyDefinition`1">
-            <summary>
-            Represents a definition of how a fake object of the type T should
-            be created.
-            </summary>
-            <typeparam name="T">The type of fake.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.IDummyDefinition">
-            <summary>
-            Represents a definition of how dummies of the specified type should be created.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IDummyDefinition.CreateDummy">
-            <summary>
-            Creates the fake.
-            </summary>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="P:FakeItEasy.IDummyDefinition.ForType">
-            <summary>
-            Gets the type of fake object the definition is for.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.DummyDefinition`1.FakeItEasy#IDummyDefinition#CreateDummy">
-            <summary>
-            Creates the dummy.
-            </summary>
-            <returns>The dummy object.</returns>
-        </member>
-        <member name="M:FakeItEasy.DummyDefinition`1.CreateDummy">
-            <summary>
-            Creates the dummy.
-            </summary>
-            <returns>The dummy object.</returns>
-        </member>
-        <member name="P:FakeItEasy.DummyDefinition`1.ForType">
-            <summary>
-            Gets the type the definition is for.
-            </summary>
-            <value>For type.</value>
-        </member>
-        <member name="T:FakeItEasy.ExceptionMessages">
-            <summary>
-              A strongly-typed resource class, for looking up localized strings, etc.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ResourceManager">
-            <summary>
-              Returns the cached ResourceManager instance used by this class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.Culture">
-            <summary>
-              Overrides the current thread's CurrentUICulture property for all
-              resource lookups using this strongly typed resource class.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ApplicatorNotSetExceptionMessage">
-            <summary>
-              Looks up a localized string similar to The Apply method of the ExpressionInterceptor may no be called before the Applicator property has been set..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ArgumentNameDoesNotExist">
-            <summary>
-              Looks up a localized string similar to The specified argument name does not exist in the ArgumentList..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ArgumentsForConstructorOnInterfaceType">
-            <summary>
-              Looks up a localized string similar to Arguments for constructor was specified when generating proxy of interface type..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ArgumentValidationDefaultMessage">
-            <summary>
-              Looks up a localized string similar to An argument validation was not configured correctly..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CalledTooFewTimesMessage">
-            <summary>
-              Looks up a localized string similar to The method &apos;{0}&apos; was called too few times, expected #{1} times but was called #{2} times..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CalledTooManyTimesMessage">
-            <summary>
-              Looks up a localized string similar to The method &apos;{0}&apos; was called too many times, expected #{1} times but was called #{2} times..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CanNotGenerateFakeMessage">
-             <summary>
-               Looks up a localized string similar to Can not create fake of the type &apos;{0}&apos;, it&apos;s not registered in the current container and the current IProxyGenerator can not generate the fake.
-            
-            The following constructors failed:
-            {1}.
-             </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.ConfiguringNonFakeObjectExceptionMessage">
-            <summary>
-              Looks up a localized string similar to Error when accessing FakeObject, the specified argument is of the type &apos;{0}&apos; which is not faked..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.CreatingExpressionCallMatcherWithNonMethodOrPropertyExpression">
-            <summary>
-              Looks up a localized string similar to An ExpressionCallMatcher can only be created for expressions that represents a method call or a property getter..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FailedToGenerateFakeWithArgumentsForConstructorPattern">
-             <summary>
-               Looks up a localized string similar to 
-            
-              The current proxy generator failed to create a proxy with the specified arguments for the constructor:
-            
-              Reason for failure:
-                - {0}
-              
-            .
-             </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FailedToGenerateProxyPattern">
-             <summary>
-               Looks up a localized string similar to FakeItEasy failed to create fake object of type &quot;{0}&quot;.
-            
-            1. The type is not registered in the current IFakeObjectContainer.
-            2. The current IProxyGenerator failed to generate a proxy for the following reason:
-            
-            {1}.
-             </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FakeCreationExceptionDefaultMessage">
-            <summary>
-              Looks up a localized string similar to Unable to create fake object..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.FakingNonAbstractClassWithArgumentsForConstructor">
-            <summary>
-              Looks up a localized string similar to Only abstract classes can be faked using the A.Fake-method that takes an enumerable of objects as arguments for constructor, use the overload that takes an expression instead..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.MemberAccessorNotCorrectExpressionType">
-            <summary>
-              Looks up a localized string similar to The member accessor expression must be a lambda expression with a MethodCallExpression or MemberAccessExpression as its body..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.MemberCanNotBeIntercepted">
-            <summary>
-              Looks up a localized string similar to The specified method can not be configured since it can not be intercepted by the current IProxyGenerator..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.MethodMissmatchWhenPlayingBackRecording">
-            <summary>
-              Looks up a localized string similar to The method of the call did not match the method of the recorded call, the recorded sequence is no longer valid..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NoConstructorMatchingArguments">
-            <summary>
-              Looks up a localized string similar to No constructor matching the specified arguments was found on the type {0}..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NoDefaultConstructorMessage">
-            <summary>
-              Looks up a localized string similar to Can not generate fake object for the class since no usable default constructor was found, specify a constructor call..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NoMoreRecordedCalls">
-            <summary>
-              Looks up a localized string similar to All the recorded calls has been applied, the recorded sequence is no longer valid..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NonConstructorExpressionMessage">
-            <summary>
-              Looks up a localized string similar to Only expression of the type ExpressionType.New (constructor calls) are accepted..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NowCalledDirectly">
-            <summary>
-              Looks up a localized string similar to The Now-method on the event raise is not meant to be called directly, only use it to register to an event on a fake object that you want to be raised..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.NumberOfOutAndRefParametersDoesNotMatchCall">
-            <summary>
-              Looks up a localized string similar to The number of values for out and ref parameters specified does not match the number of out and ref parameters in the call..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.OrderedAssertionsAlreadyOpen">
-            <summary>
-              Looks up a localized string similar to A scope for ordered assertions is already opened, close that scope before opening another one..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.SpecifiedCallIsNotToFakedObject">
-            <summary>
-              Looks up a localized string similar to The specified call is not made on a fake object..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.TypeCanNotBeProxied">
-            <summary>
-              Looks up a localized string similar to The current fake proxy generator can not create proxies of the type {0}..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.UnableToCreateDummyPattern">
-            <summary>
-              Looks up a localized string similar to FakeItEasy was unable to create dummy of type &quot;{0}&quot;, register it in the current IFakeObjectContainer to enable this..
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.WasCalledWrongNumberOfTimes">
-            <summary>
-              Looks up a localized string similar to Expected to find call {0} the number of times specified by the predicate &apos;{1}&apos; but found it {2} times among the calls:.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.ExceptionMessages.WrongNumberOfArgumentNamesMessage">
-            <summary>
-              Looks up a localized string similar to The number of argument names does not match the number of arguments..
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.ExpectationException">
-            <summary>
-            An exception thrown when an expectation is not met (when asserting on fake object calls).
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.ExpectationException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.ExpectationException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ICallExpressionParser">
-            <summary>
-            Represents a class that can parse a lambda expression
-            that represents a method or property call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ICallExpressionParser.Parse(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Parses the specified expression.
-            </summary>
-            <param name="callExpression">The expression to parse.</param>
-            <returns>The parsed expression.</returns>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionCallMatcher">
-            <summary>
-            Handles the matching of fake object calls to expressions.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallMatcher.#ctor(System.Linq.Expressions.LambdaExpression,FakeItEasy.Expressions.ExpressionArgumentConstraintFactory,FakeItEasy.Core.MethodInfoManager,FakeItEasy.Expressions.ICallExpressionParser)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Expressions.ExpressionCallMatcher"/> class.
-            </summary>
-            <param name="callSpecification">The call specification.</param>
-            <param name="constraintFactory">The constraint factory.</param>
-            <param name="methodInfoManager">The method info manager to use.</param>
-            <param name="callExpressionParser">A parser to use to parse call expressions.</param>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallMatcher.Matches(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Matches the specified call against the expression.
-            </summary>
-            <param name="call">The call to match.</param>
-            <returns>True if the call is matched by the expression.</returns>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallMatcher.ToString">
-            <summary>
-            Gets a description of the call.
-            </summary>
-            <returns>Description of the call.</returns>
-        </member>
-        <member name="P:FakeItEasy.Expressions.ExpressionCallMatcher.DescriptionOfMatchingCall">
-            <summary>
-            Gets a human readable description of calls that will be matched by this
-            matcher.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionCallRule">
-            <summary>
-            An implementation of the <see cref="T:FakeItEasy.Core.IFakeObjectCallRule"/> interface that uses
-            expressions for evaluating if the rule is applicable to a specific call.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallRule.#ctor(FakeItEasy.Expressions.ExpressionCallMatcher)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Expressions.ExpressionCallRule"/> class.
-            </summary>
-            <param name="expressionMatcher">The expression matcher to use.</param>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionCallRule.ToString">
-            <summary>
-            Returns a <see cref="T:System.String"/> that represents this instance.
-            </summary>
-            <returns>
-            A <see cref="T:System.String"/> that represents this instance.
-            </returns>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionCallRule.Factory">
-            <summary>
-            Handles the instantiation of ExpressionCallRule instance.
-            </summary>
-            <param name="callSpecification">An expression specifying the call.</param>
-            <returns>A rule instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.Expressions.ExpressionParser">
-            <summary>
-            Manages breaking call specification expression into their various parts.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Expressions.IExpressionParser">
-            <summary>
-            Manages breaking call specification expression into their various parts.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Expressions.IExpressionParser.GetFakeManagerCallIsMadeOn(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Gets the fake object an expression is called on.
-            </summary>
-            <param name="fakeObjectCall">The call expression.</param>
-            <returns>The FakeManager instance that manages the faked object the call is made on.</returns>
-            <exception cref="T:System.ArgumentNullException">The fakeObjectCall is null.</exception>
-            <exception cref="T:System.ArgumentException">The specified expression is not an expression where a call is made to a faked object.</exception>
-        </member>
-        <member name="M:FakeItEasy.Expressions.ExpressionParser.GetFakeManagerCallIsMadeOn(System.Linq.Expressions.LambdaExpression)">
-            <summary>
-            Gets the fake object an expression is called on.
-            </summary>
-            <param name="fakeObjectCall">The call expression.</param>
-            <returns>A FakeObject.</returns>
-            <exception cref="T:System.ArgumentNullException">The fakeObjectCall is null.</exception>
-            <exception cref="T:System.ArgumentException">The specified expression is not an expression where a call is made to a faked object.</exception>
-        </member>
-        <member name="T:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax">
-            <summary>
-            Provides extension methods for configuring and asserting on faked objects
-            without going through the static methods of the Fake-class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax.CallsTo``2(``0,System.Linq.Expressions.Expression{System.Func{``0,``1}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <typeparam name="TFake">The type of fake object to configure.</typeparam>
-            <typeparam name="TMember">The type of the return value of the member.</typeparam>
-            <param name="fakedObject">The faked object to configure.</param>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax.CallsTo``1(``0,System.Linq.Expressions.Expression{System.Action{``0}})">
-            <summary>
-            Configures the behavior of the fake object when a call that matches the specified
-            call happens.
-            </summary>
-            <param name="fakedObject">The faked object to configure.</param>
-            <typeparam name="TFake">The type of fake object to configure.</typeparam>
-            <param name="callSpecification">An expression that specifies the calls to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Full.FullExtensionSyntax.AnyCall``1(``0)">
-            <summary>
-            Configures the behavior of the fake object when a call is made to any method on the
-            object.
-            </summary>
-            <typeparam name="TFake">The type of the fake.</typeparam>
-            <param name="fakedObject">The faked object.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.ExtensionSyntax.Syntax">
-            <summary>
-            Provides an extension method for configuring fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.ExtensionSyntax.Syntax.Configure``1(``0)">
-            <summary>
-            Gets an object that provides a fluent interface syntax for configuring
-            the fake object.
-            </summary>
-            <typeparam name="TFake">The type of the fake object.</typeparam>
-            <param name="fakedObject">The fake object to configure.</param>
-            <returns>A configuration object.</returns>
-            <exception cref="T:System.ArgumentNullException">The fakedObject was null.</exception>
-            <exception cref="T:System.ArgumentException">The object passed in is not a faked object.</exception>
-        </member>
-        <member name="T:FakeItEasy.Fake">
-            <summary>
-            Provides static methods for accessing fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Fake.GetFakeManager(System.Object)">
-            <summary>
-            Gets the fake object that manages the faked object.
-            </summary>
-            <param name="fakedObject">The faked object to get the manager object for.</param>
-            <returns>The fake object manager.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.CreateScope">
-            <summary>
-            Creates a new scope and sets it as the current scope. When inside a scope the
-            getting the calls made to a fake will return only the calls within that scope and when
-            asserting that calls were made, the calls must have been made within that scope.
-            </summary>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.CreateScope(FakeItEasy.Core.IFakeObjectContainer)">
-            <summary>
-            Creates a new scope and sets it as the current scope. When inside a scope the
-            getting the calls made to a fake will return only the calls within that scope and when
-            asserting that calls were made, the calls must have been made within that scope.
-            </summary>
-            <param name="container">The container to use within the specified scope.</param>
-            <returns>The created scope.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.Equals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are equal.
-            </summary>
-            <param name="objA">The first object to compare.</param>
-            <param name="objB">The second object to compare.</param>
-            <returns>True if the two objects are equal.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.ReferenceEquals(System.Object,System.Object)">
-            <summary>
-            Gets a value indicating whether the two objects are the same reference.
-            </summary>
-            <param name="objA">The object A.</param>
-            <param name="objB">The object B.</param>
-            <returns>True if the objects are the same reference.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake.GetCalls(System.Object)">
-            <summary>
-            Gets all the calls made to the specified fake object.
-            </summary>
-            <param name="fakedObject">The faked object.</param>
-            <returns>A collection containing the calls to the object.</returns>
-            <exception cref="T:System.ArgumentException">The object passed in is not a faked object.</exception>
-        </member>
-        <member name="M:FakeItEasy.Fake.ClearConfiguration(System.Object)">
-            <summary>
-            Clears the configuration of the faked object.
-            </summary>
-            <param name="fakedObject">The faked object to clear the configuration of.</param>
-        </member>
-        <member name="M:FakeItEasy.Fake.InitializeFixture(System.Object)">
-            <summary>
-            Sets a new fake to each property or field that is tagged with the FakeAttribute in the specified
-            fixture.
-            </summary>
-            <param name="fixture">The object to initialize.</param>
-        </member>
-        <member name="T:FakeItEasy.Fake`1">
-            <summary>
-            Represents a fake object that provides an API for configuring a faked object, exposed by the
-            FakedObject-property.
-            </summary>
-            <typeparam name="T">The type of the faked object.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Fake`1"/> class. 
-            Creates a new fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.#ctor(System.Action{FakeItEasy.Creation.IFakeOptionsBuilder{`0}})">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.Fake`1"/> class. 
-            Creates a new fake object using the specified options.
-            </summary>
-            <param name="options">
-            Options used to create the fake object.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.CallsTo(System.Linq.Expressions.Expression{System.Action{`0}})">
-            <summary>
-            Configures calls to the specified member.
-            </summary>
-            <param name="callSpecification">An expression specifying the call to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.CallsTo``1(System.Linq.Expressions.Expression{System.Func{`0,``0}})">
-            <summary>
-            Configures calls to the specified member.
-            </summary>
-            <typeparam name="TMember">The type of value the member returns.</typeparam>
-            <param name="callSpecification">An expression specifying the call to configure.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.Fake`1.AnyCall">
-            <summary>
-            Configures any call to the fake object.
-            </summary>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="P:FakeItEasy.Fake`1.FakedObject">
-            <summary>
-            Gets the faked object.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Fake`1.RecordedCalls">
-            <summary>
-            Gets all calls made to the faked object.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.FakeAttribute">
-            <summary>
-            Used to tag fields and properties that will be initialized through the
-            Fake.Initialize-method.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.FakeConfigurator`1">
-            <summary>
-            Provides the base implementation for the IFakeConfigurator-interface.
-            </summary>
-            <typeparam name="T">The type of fakes the configurator can configure.</typeparam>
-        </member>
-        <member name="T:FakeItEasy.IFakeConfigurator">
-            <summary>
-            Provides configurations for fake objects of a specific type.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IFakeConfigurator.ConfigureFake(System.Object)">
-            <summary>
-            Applies the configuration for the specified fake object.
-            </summary>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="P:FakeItEasy.IFakeConfigurator.ForType">
-            <summary>
-            Gets the type the instance provides configuration for.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.FakeConfigurator`1.ConfigureFake(`0)">
-            <summary>
-            Configures the fake.
-            </summary>
-            <param name="fakeObject">The fake object.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeConfigurator`1.FakeItEasy#IFakeConfigurator#ConfigureFake(System.Object)">
-            <summary>
-            Applies the configuration for the specified fake object.
-            </summary>
-            <param name="fakeObject">The fake object to configure.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeConfigurator`1.AssertThatFakeIsOfCorrectType(System.Object)">
-            <summary>
-            Asserts the type of the that fake is of correct.
-            </summary>
-            <param name="fakeObject">The fake object.</param>
-        </member>
-        <member name="P:FakeItEasy.FakeConfigurator`1.ForType">
-            <summary>
-            Gets the type the instance provides configuration for.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.FakeExtensions">
-            <summary>
-            Provides extension methods for fake objects.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Once(FakeItEasy.Configuration.IRepeatConfiguration)">
-            <summary>
-            Specifies NumberOfTimes(1) to the IRepeatConfiguration{TFake}.
-            </summary>
-            <param name="configuration">The configuration to set repeat 1 to.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Twice(FakeItEasy.Configuration.IRepeatConfiguration)">
-            <summary>
-            Specifies NumberOfTimes(2) to the IRepeatConfiguration{TFake}.
-            </summary>
-            <param name="configuration">The configuration to set repeat 2 to.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.WithAnyArguments``1(FakeItEasy.Configuration.IArgumentValidationConfiguration{``0})">
-            <summary>
-            Specifies that a call to the configured call should be applied no matter what arguments
-            are used in the call to the faked object.
-            </summary>
-            <typeparam name="TInterface">The type of the interface.</typeparam>
-            <param name="configuration">The configuration.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Matching``1(System.Collections.Generic.IEnumerable{FakeItEasy.Core.ICompletedFakeObjectCall},System.Linq.Expressions.Expression{System.Action{``0}})">
-            <summary>
-            Filters to contain only the calls that matches the call specification.
-            </summary>
-            <typeparam name="TFake">The type of fake the call is made on.</typeparam>
-            <param name="calls">The calls to filter.</param>
-            <param name="callSpecification">The call to match on.</param>
-            <returns>A collection of the calls that matches the call specification.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.MustHaveHappened(FakeItEasy.Configuration.IAssertConfiguration)">
-            <summary>
-            Asserts that the specified call must have happened once or more.
-            </summary>
-            <param name="configuration">The configuration to assert on.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.MustNotHaveHappened(FakeItEasy.Configuration.IAssertConfiguration)">
-            <summary>
-            Asserts that the specified has not happened.
-            </summary>
-            <param name="configuration">The configuration to assert on.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsNextFromSequence``1(FakeItEasy.Configuration.IReturnValueConfiguration{``0},``0[])">
-            <summary>
-            Configures the call to return the next value from the specified sequence each time it's called. Null will
-            be returned when all the values in the sequence has been returned.
-            </summary>
-            <typeparam name="T">
-            The type of return value.
-            </typeparam>
-            <param name="configuration">
-            The call configuration to extend.
-            </param>
-            <param name="values">
-            The values to return in sequence.
-            </param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Returns``1(FakeItEasy.Configuration.IReturnValueConfiguration{``0},``0)">
-            <summary>
-            Specifies the value to return when the configured call is made.
-            </summary>
-            <typeparam name="T">The type of the return value.</typeparam>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="value">The value to return.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``1(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <typeparam name="T">The type of the return value.</typeparam>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``2(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``3(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``2,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``4(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``2,``3,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.ReturnsLazily``5(FakeItEasy.Configuration.IReturnValueConfiguration{``0},System.Func{``1,``2,``3,``4,``0})">
-            <summary>
-            Specifies a function used to produce a return value when the configured call is made.
-            The function will be called each time this call is made and can return different values
-            each time.
-            </summary>
-            <param name="configuration">The configuration to extend.</param>
-            <param name="valueProducer">A function that produces the return value.</param>
-            <typeparam name="TReturnType">The type of the return value.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the faked method call.</typeparam>
-            <returns>A configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="valueProducer"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Write``1(System.Collections.Generic.IEnumerable{``0},FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes the calls in the collection to the specified text writer.
-            </summary>
-            <typeparam name="T">The type of the calls.</typeparam>
-            <param name="calls">The calls to write.</param>
-            <param name="writer">The writer to write the calls to.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.WriteToConsole``1(System.Collections.Generic.IEnumerable{``0})">
-            <summary>
-            Writes all calls in the collection to the console.
-            </summary>
-            <typeparam name="T">The type of the calls.</typeparam>
-            <param name="calls">The calls to write.</param>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.GetArgument``1(FakeItEasy.Core.IFakeObjectCall,System.Int32)">
-            <summary>
-            Gets the argument at the specified index in the arguments collection
-            for the call.
-            </summary>
-            <typeparam name="T">The type of the argument to get.</typeparam>
-            <param name="call">The call to get the argument from.</param>
-            <param name="argumentIndex">The index of the argument.</param>
-            <returns>The value of the argument with the specified index.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.GetArgument``1(FakeItEasy.Core.IFakeObjectCall,System.String)">
-            <summary>
-            Gets the argument with the specified name in the arguments collection
-            for the call.
-            </summary>
-            <typeparam name="T">The type of the argument to get.</typeparam>
-            <param name="call">The call to get the argument from.</param>
-            <param name="argumentName">The name of the argument.</param>
-            <returns>The value of the argument with the specified name.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Strict``1(FakeItEasy.Creation.IFakeOptionsBuilder{``0})">
-            <summary>
-            Makes the fake strict, this means that any call to the fake
-            that has not been explicitly configured will throw an exception.
-            </summary>
-            <typeparam name="T">The type of fake object.</typeparam>
-            <param name="options">The configuration.</param>
-            <returns>A configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Where``1(FakeItEasy.Configuration.IWhereConfiguration{``0},System.Linq.Expressions.Expression{System.Func{FakeItEasy.Core.IFakeObjectCall,System.Boolean}})">
-            <summary>
-            Applies a predicate to constrain which calls will be considered for interception.
-            </summary>
-            <typeparam name="T">
-            The return type of the where method.
-            </typeparam>
-            <param name="configuration">
-            The configuration object to extend.
-            </param>
-            <param name="predicate">
-            A predicate for a fake object call.
-            </param>
-            to the output.
-            <returns>
-            The configuration object.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``1(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action)">
-            <summary>
-            Executes the specified action when a matching call is being made. This overload can also be used to fake calls with arguments when they don't need to be accessed.
-            </summary>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action"/> to invoke.</param>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``2(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`1"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``3(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1,``2})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`2"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``4(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1,``2,``3})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`3"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Invokes``5(FakeItEasy.Configuration.ICallbackConfiguration{``0},System.Action{``1,``2,``3,``4})">
-            <summary>
-            Executes the specified action when a matching call is being made.
-            </summary>
-            <param name="configuration">The configuration that is extended.</param>
-            <param name="actionToInvoke">The <see cref="T:System.Action`4"/> to invoke.</param>
-            <typeparam name="TFake">The type of fake object.</typeparam>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the faked method call.</typeparam>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="actionToInvoke"/> do not match.</exception>
-            <returns>The fake object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Exception)">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exception">The exception to throw when a call that matches is invoked.</param>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``1(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``2(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,``1,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``3(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,``1,``2,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``4(FakeItEasy.Configuration.IExceptionThrowerConfiguration,System.Func{``0,``1,``2,``3,System.Exception})">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <param name="exceptionFactory">A function that returns the exception to throw when invoked.</param>
-            <typeparam name="T1">Type of the first argument of the faked method call.</typeparam>
-            <typeparam name="T2">Type of the second argument of the faked method call.</typeparam>
-            <typeparam name="T3">Type of the third argument of the faked method call.</typeparam>
-            <typeparam name="T4">Type of the fourth argument of the faked method call.</typeparam>
-            <returns>Configuration object.</returns>
-            <exception cref="T:FakeItEasy.Configuration.FakeConfigurationException">The signatures of the faked method and the <paramref name="exceptionFactory"/> do not match.</exception>
-        </member>
-        <member name="M:FakeItEasy.FakeExtensions.Throws``1(FakeItEasy.Configuration.IExceptionThrowerConfiguration)">
-            <summary>
-            Throws the specified exception when the currently configured
-            call gets called.
-            </summary>
-            <param name="configuration">The configuration to use.</param>
-            <typeparam name="T">The type of exception to throw.</typeparam>
-            <returns>Configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.Guard">
-            <summary>
-            Provides methods for guarding method arguments.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Guard.AgainstNull(System.Object,System.String)">
-            <summary>
-            Throws an exception if the specified argument is null.
-            </summary>
-            <param name="argument">The argument.</param>
-            <param name="argumentName">Name of the argument.</param>
-            <exception cref="T:System.ArgumentNullException">The specified argument was null.</exception>
-        </member>
-        <member name="T:FakeItEasy.Guard.ValidatedNotNullAttribute">
-            <summary>
-            When applied to a parameter, this attribute provides an indication to code analysis that the argument has been null checked.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Helpers.GetValueProducedByExpression(System.Linq.Expressions.Expression)">
-            <summary>
-            Gets the value produced by the specified expression when compiled and invoked.
-            </summary>
-            <param name="expression">The expression to get the value from.</param>
-            <returns>The value produced by the expression.</returns>
-        </member>
-        <member name="T:FakeItEasy.IFileSystem">
-            <summary>
-            Provides access to the file system.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IFileSystem.Open(System.String,System.IO.FileMode)">
-            <summary>
-            Opens the specified file in the specified mode.
-            </summary>
-            <param name="fileName">The full path and name of the file to open.</param>
-            <param name="mode">The mode to open the file in.</param>
-            <returns>A stream for reading and writing the file.</returns>
-        </member>
-        <member name="M:FakeItEasy.IFileSystem.FileExists(System.String)">
-            <summary>
-            Gets a value indicating whether the specified file exists.
-            </summary>
-            <param name="fileName">The path and name of the file to check.</param>
-            <returns>True if the file exists.</returns>
-        </member>
-        <member name="M:FakeItEasy.IFileSystem.Create(System.String)">
-            <summary>
-            Creates a file with the specified name.
-            </summary>
-            <param name="fileName">The name of the file to create.</param>
-        </member>
-        <member name="T:FakeItEasy.IoC.DictionaryContainer">
-            <summary>
-            A simple implementation of an IoC container.
-            </summary>
-        </member>
-        <member name="F:FakeItEasy.IoC.DictionaryContainer.registeredServices">
-            <summary>
-            The dictionary that stores the registered services.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.IoC.DictionaryContainer"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.Resolve(System.Type)">
-            <summary>
-            Resolves an instance of the specified component type.
-            </summary>
-            <param name="componentType">Type of the component.</param>
-            <returns>An instance of the component type.</returns>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.Register``1(System.Func{FakeItEasy.IoC.DictionaryContainer,``0})">
-            <summary>
-            Registers the specified resolver.
-            </summary>
-            <typeparam name="T">The type of component to register.</typeparam>
-            <param name="resolver">The resolver.</param>
-        </member>
-        <member name="M:FakeItEasy.IoC.DictionaryContainer.RegisterSingleton``1(System.Func{FakeItEasy.IoC.DictionaryContainer,``0})">
-            <summary>
-            Registers the specified resolver as a singleton.
-            </summary>
-            <typeparam name="T">The type of component to register.</typeparam>
-            <param name="resolver">The resolver.</param>
-        </member>
-        <member name="T:FakeItEasy.IRepeatSpecification">
-            <summary>
-            Provides properties and methods to specify repeat.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.IRepeatSpecification.Times(System.Int32)">
-            <summary>
-            Specifies the number of times as repeat.
-            </summary>
-            <param name="numberOfTimes">The number of times expected.</param>
-            <returns>A Repeated instance.</returns>
-        </member>
-        <member name="P:FakeItEasy.IRepeatSpecification.Once">
-            <summary>
-            Specifies once as the repeat.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.IRepeatSpecification.Twice">
-            <summary>
-            Specifies twice as the repeat.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.NextCall">
-            <summary>
-            Lets you specify options for the next call to a fake object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.NextCall.To``1(``0)">
-            <summary>
-            Specifies options for the next call to the specified fake object. The next call will
-            be recorded as a call configuration.
-            </summary>
-            <typeparam name="TFake">The type of the faked object.</typeparam>
-            <param name="fake">The faked object to configure.</param>
-            <returns>A call configuration object.</returns>
-        </member>
-        <member name="T:FakeItEasy.OrderedAssertion">
-            <summary>
-            Provides functionality for making ordered assertions on fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.OrderedAssertion.OrderedAssertions(System.Collections.Generic.IEnumerable{FakeItEasy.Core.ICompletedFakeObjectCall})">
-            <summary>
-            Creates a scope that changes the behavior on asserts so that all asserts within
-            the scope must be to calls in the specified collection of calls. Calls must have happened
-            in the order that the asserts are specified or the asserts will fail.
-            </summary>
-            <param name="calls">The calls to assert among.</param>
-            <returns>A disposable used to close the scope.</returns>
-        </member>
-        <member name="T:FakeItEasy.OutputWriter">
-            <summary>
-            Provides static methods for the IOutputWriter-interface.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.OutputWriter.WriteLine(FakeItEasy.IOutputWriter)">
-            <summary>
-            Writes a new line to the writer.
-            </summary>
-            <param name="writer">The writer to write to.</param>
-            <returns>The writer.</returns>
-        </member>
-        <member name="M:FakeItEasy.OutputWriter.Write(FakeItEasy.IOutputWriter,System.String,System.Object[])">
-            <summary>
-            Writes the format string to the writer.
-            </summary>
-            <param name="writer">The writer to write to.</param>
-            <param name="format">The format string to write.</param>
-            <param name="args">Replacements for the format string.</param>
-            <returns>The writer.</returns>
-        </member>
-        <member name="M:FakeItEasy.OutputWriter.Write(FakeItEasy.IOutputWriter,System.Object)">
-            <summary>
-            Writes the specified object to the writer (using the ToString-method of the object).
-            </summary>
-            <param name="writer">The writer to write to.</param>
-            <param name="value">The value to write to the writer.</param>
-            <returns>The writer.</returns>
-        </member>
-        <member name="T:FakeItEasy.Raise">
-            <summary>
-            Allows the developer to raise an event on a faked object.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.Raise.With``1(System.Object,``0)">
-            <summary>
-            Raises an event on a faked object by attaching the event handler produced by the method
-            to the event that is to be raised.
-            </summary>
-            <typeparam name="TEventArgs">The type of the event args.</typeparam>
-            <param name="sender">The sender of the event.</param>
-            <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
-            <returns>A Raise(TEventArgs)-object that exposes the event handler to attach.</returns>
-        </member>
-        <member name="M:FakeItEasy.Raise.With``1(``0)">
-            <summary>
-            Raises an event on a faked object by attaching the event handler produced by the method
-            to the event that is to be raised.
-            </summary>
-            <typeparam name="TEventArgs">The type of the event arguments.</typeparam>
-            <param name="e">The <see cref="T:System.EventArgs"/> instance containing the event data.</param>
-            <returns>
-            A Raise(TEventArgs)-object that exposes the event handler to attach.
-            </returns>
-        </member>
-        <member name="M:FakeItEasy.Raise.WithEmpty">
-            <summary>
-            Raises an event with empty event arguments on a faked object by attaching the event handler produced by the method
-            to the event that is to be raised.
-            </summary>
-            <returns>
-            A Raise(TEventArgs)-object that exposes the event handler to attach.
-            </returns>
-        </member>
-        <member name="T:FakeItEasy.Raise`1">
-            <summary>
-            A class exposing an event handler to attach to an event of a faked object
-            in order to raise that event.
-            </summary>
-            <typeparam name="TEventArgs">The type of the event args.</typeparam>
-        </member>
-        <member name="M:FakeItEasy.Raise`1.Now(System.Object,`0)">
-            <summary>
-            Register this event handler to an event on a faked object in order to raise that event.
-            </summary>
-            <param name="sender">The sender of the event.</param>
-            <param name="e">Event args for the event.</param>
-        </member>
-        <member name="P:FakeItEasy.Raise`1.Go">
-            <summary>
-            Gets a generic event handler to attach to the event to raise.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Recorders">
-            <summary>
-            Provides methods for creating recorders for self initializing fakes.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.Repeated">
-            <summary>
-            Provides syntax for specifying the number of times a call must have been repeated when asserting on 
-            fake object calls.
-            </summary>
-            <example><code>A.CallTo(() => foo.Bar()).Assert(Happened.Once.Exactly);</code></example>
-        </member>
-        <member name="M:FakeItEasy.Repeated.Like(System.Linq.Expressions.Expression{System.Func{System.Int32,System.Boolean}})">
-            <summary>
-            Specifies that a call must have been repeated a number of times
-            that is validated by the specified repeatValidation argument.
-            </summary>
-            <param name="repeatValidation">A predicate that specifies the number of times
-            a call must have been made.</param>
-            <returns>A Repeated-instance.</returns>
-        </member>
-        <member name="M:FakeItEasy.Repeated.Matches(System.Int32)">
-            <summary>
-            When implemented gets a value indicating if the repeat is matched
-            by the Happened-instance.
-            </summary>
-            <param name="repeat">The repeat of a call.</param>
-            <returns>True if the repeat is a match.</returns>
-        </member>
-        <member name="P:FakeItEasy.Repeated.Never">
-            <summary>
-            Asserts that a call has not happened at all.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Repeated.Exactly">
-            <summary>
-            The call must have happened exactly the number of times that is specified in the next step.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Repeated.AtLeast">
-            <summary>
-            The call must have happened any number of times greater than or equal to the number of times that is specified
-            in the next step.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.Repeated.NoMoreThan">
-            <summary>
-            The call must have happened any number of times less than or equal to the number of times that is specified
-            in the next step.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.RootModule">
-            <summary>
-            Handles the registration of root dependencies in an IoC-container.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.RootModule.RegisterDependencies(FakeItEasy.IoC.DictionaryContainer)">
-            <summary>
-            Registers the dependencies.
-            </summary>
-            <param name="container">The container to register the dependencies in.</param>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.CallData">
-            <summary>
-            DTO for recorded calls.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.CallData.#ctor(System.Reflection.MethodInfo,System.Collections.Generic.IEnumerable{System.Object},System.Object)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.CallData"/> class.
-            </summary>
-            <param name="method">The method.</param>
-            <param name="outputArguments">The output arguments.</param>
-            <param name="returnValue">The return value.</param>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.CallData.Method">
-            <summary>
-            Gets the method that was called.
-            </summary>
-            <value>The method.</value>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.CallData.OutputArguments">
-            <summary>
-            Gets the output arguments of the call.
-            </summary>
-            <value>The output arguments.</value>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.CallData.ReturnValue">
-            <summary>
-            Gets the return value of the call.
-            </summary>
-            <value>The return value.</value>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.ICallStorage">
-            <summary>
-            Represents storage for recorded calls for self initializing
-            fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ICallStorage.Load">
-            <summary>
-            Loads the recorded calls for the specified recording.
-            </summary>
-            <returns>The recorded calls for the recording with the specified id.</returns>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ICallStorage.Save(System.Collections.Generic.IEnumerable{FakeItEasy.SelfInitializedFakes.CallData})">
-            <summary>
-            Saves the specified calls as the recording with the specified id,
-            overwriting any previous recording.
-            </summary>
-            <param name="calls">The calls to save.</param>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder">
-            <summary>
-            An interface for recorders that provides stored responses for self initializing fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder.ApplyNext(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies the call if the call has been recorded.
-            </summary>
-            <param name="fakeObjectCall">The call to apply to from recording.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder.RecordCall(FakeItEasy.Core.ICompletedFakeObjectCall)">
-            <summary>
-            Records the specified call.
-            </summary>
-            <param name="fakeObjectCall">The call to record.</param>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder.IsRecording">
-            <summary>
-            Gets a value indicating whether the recorder is currently recording.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.RecordingException">
-            <summary>
-            An exception that can be thrown when recording for self initialized
-            fakes fails or when playback fails.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor(System.String)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingException.#ctor(System.String,System.Exception)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingException"/> class.
-            </summary>
-            <param name="message">The message.</param>
-            <param name="innerException">The inner exception.</param>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.RecordingManager">
-            <summary>
-            Manages the applying of recorded calls and recording of new calls when
-            using self initialized fakes.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.#ctor(FakeItEasy.SelfInitializedFakes.ICallStorage)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.RecordingManager"/> class.
-            </summary>
-            <param name="storage">The storage.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.ApplyNext(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies the call if the call has been recorded.
-            </summary>
-            <param name="fakeObjectCall">The call to apply to from recording.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.RecordCall(FakeItEasy.Core.ICompletedFakeObjectCall)">
-            <summary>
-            Records the specified call.
-            </summary>
-            <param name="fakeObjectCall">The call to record.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.RecordingManager.Dispose">
-            <summary>
-            Saves all recorded calls to the storage.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.RecordingManager.IsRecording">
-            <summary>
-            Gets a value indicating whether the recorder is currently recording.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.RecordingManager.Factory">
-            <summary>
-            Represents a factory responsible for creating recording manager
-            instances.
-            </summary>
-            <param name="storage">The storage the manager should use.</param>
-            <returns>A RecordingManager instance.</returns>
-        </member>
-        <member name="T:FakeItEasy.SelfInitializedFakes.SelfInitializationRule">
-            <summary>
-            A call rule use for self initializing fakes, delegates call to
-            be applied by the recorder.
-            </summary>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.#ctor(FakeItEasy.Core.IFakeObjectCallRule,FakeItEasy.SelfInitializedFakes.ISelfInitializingFakeRecorder)">
-            <summary>
-            Initializes a new instance of the <see cref="T:FakeItEasy.SelfInitializedFakes.SelfInitializationRule"/> class.
-            </summary>
-            <param name="wrappedRule">The wrapped rule.</param>
-            <param name="recorder">The recorder.</param>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.IsApplicableTo(FakeItEasy.Core.IFakeObjectCall)">
-            <summary>
-            Gets whether this interceptor is applicable to the specified
-            call, if true is returned the Apply-method of the interceptor will
-            be called.
-            </summary>
-            <param name="fakeObjectCall">The call to check for applicability.</param>
-            <returns>True if the interceptor is applicable.</returns>
-        </member>
-        <member name="M:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.Apply(FakeItEasy.Core.IInterceptedFakeObjectCall)">
-            <summary>
-            Applies an action to the call, might set a return value or throw
-            an exception.
-            </summary>
-            <param name="fakeObjectCall">The call to apply the interceptor to.</param>
-        </member>
-        <member name="P:FakeItEasy.SelfInitializedFakes.SelfInitializationRule.NumberOfTimesToCall">
-            <summary>
-            Gets the number of times this call rule is valid, if it's set
-            to null its infinitely valid.
-            </summary>
-            <value></value>
-        </member>
-        <member name="T:FakeItEasy.SmellyAttribute">
-            <summary>
-            An attribute that can be applied to code that should be fixed because there's a
-            code smell.
-            </summary>
-        </member>
-        <member name="P:FakeItEasy.SmellyAttribute.Description">
-            <summary>
-            Gets or sets the description of the smell.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.UnderTestAttribute">
-            <summary>
-            Used to tag fields and properties that will be initialized as a SUT through the Fake.Initialize-method.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.SerializableAttribute">
-            <summary>
-            Fixes so that existing Serializable-attributes are omitted in the compilation
-            of the silverlight project.
-            </summary>
-        </member>
-        <member name="T:FakeItEasy.NonSerializedAttribute">
-            <summary>
-            Fixes so that existing NonSerialized-attributes are omitted in the compilation
-            of the silverlight project.
-            </summary>
-        </member>
-    </members>
-</doc>
diff --git a/dep/repositories.config b/dep/repositories.config
index ee09227463b..bc0d4524401 100644
--- a/dep/repositories.config
+++ b/dep/repositories.config
@@ -9,7 +9,6 @@
   <repository path="..\src\Profiling\Profiling.Indexing\packages.config" />
   <repository path="..\src\Profiling\Profiling.InMemoryConnection\packages.config" />
   <repository path="..\src\Serialization\Elasticsearch.Net.JsonNET\packages.config" />
-  <repository path="..\src\Serialization\Elasticsearch.Net.ServiceStackText\packages.config" />
   <repository path="..\src\Tests\Elasticsearch.Net.Integration.Yaml\packages.config" />
   <repository path="..\src\Tests\Elasticsearch.Net.Tests.Unit\packages.config" />
   <repository path="..\src\Tests\Nest.Tests.Integration\packages.config" />
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Elasticsearch.Net.Tests.Unit.csproj b/src/Tests/Elasticsearch.Net.Tests.Unit/Elasticsearch.Net.Tests.Unit.csproj
index 7e8daf586e6..0e972379680 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Elasticsearch.Net.Tests.Unit.csproj
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Elasticsearch.Net.Tests.Unit.csproj
@@ -30,12 +30,13 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Autofac">
-      <HintPath>..\..\..\dep\Autofac.3.2.0\lib\net40\Autofac.dll</HintPath>
+    <Reference Include="Autofac, Version=3.3.0.0, Culture=neutral, PublicKeyToken=17863af14b0044da, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\dep\Autofac.3.3.1\lib\net40\Autofac.dll</HintPath>
     </Reference>
     <Reference Include="Autofac.Extras.FakeItEasy, Version=3.0.0.0, Culture=neutral, PublicKeyToken=17863af14b0044da, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\dep\Autofac.Extras.FakeItEasy.3.0.1\lib\net40\Autofac.Extras.FakeItEasy.dll</HintPath>
+      <HintPath>..\..\..\dep\Autofac.Extras.FakeItEasy.3.0.2\lib\net40\Autofac.Extras.FakeItEasy.dll</HintPath>
     </Reference>
     <Reference Include="FakeItEasy, Version=1.18.0.0, Culture=neutral, PublicKeyToken=eff28e2146d5fd2c, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/packages.config b/src/Tests/Elasticsearch.Net.Tests.Unit/packages.config
index cef089808bc..a31532a474f 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/packages.config
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/packages.config
@@ -1,8 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Autofac" version="3.2.0" targetFramework="net45" />
-  <package id="Autofac.Extras.FakeItEasy" version="3.0.1" targetFramework="net45" />
-  <package id="FakeItEasy" version="1.15.0" targetFramework="net45" />
+  <package id="Autofac" version="3.3.1" targetFramework="net45" />
+  <package id="Autofac.Extras.FakeItEasy" version="3.0.2" targetFramework="net45" />
   <package id="FakeItEasy" version="1.18.0" targetFramework="net45" />
   <package id="FluentAssertions" version="2.2.0.0" targetFramework="net45" />
   <package id="NUnit" version="2.6.3" targetFramework="net45" />
diff --git a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
index 9b77a5b41de..1239891f5cf 100644
--- a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
+++ b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
@@ -71,9 +71,9 @@
     <Reference Include="AutoPoco">
       <HintPath>..\..\..\dep\AutoPoco.1.0.0.0\lib\AutoPoco.dll</HintPath>
     </Reference>
-    <Reference Include="FakeItEasy, Version=1.15.0.0, Culture=neutral, PublicKeyToken=eff28e2146d5fd2c, processorArchitecture=MSIL">
+    <Reference Include="FakeItEasy, Version=1.18.0.0, Culture=neutral, PublicKeyToken=eff28e2146d5fd2c, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\..\dep\FakeItEasy.1.15.0\lib\net40\FakeItEasy.dll</HintPath>
+      <HintPath>..\..\..\dep\FakeItEasy.1.18.0\lib\net40\FakeItEasy.dll</HintPath>
     </Reference>
     <Reference Include="FluentAssertions">
       <HintPath>..\..\..\dep\FluentAssertions.2.2.0.0\lib\net45\FluentAssertions.dll</HintPath>
diff --git a/src/Tests/Nest.Tests.Unit/packages.config b/src/Tests/Nest.Tests.Unit/packages.config
index c03f0318ed9..cb820f05364 100644
--- a/src/Tests/Nest.Tests.Unit/packages.config
+++ b/src/Tests/Nest.Tests.Unit/packages.config
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AutoPoco" version="1.0.0.0" targetFramework="net40" />
-  <package id="FakeItEasy" version="1.15.0" targetFramework="net40" />
+  <package id="FakeItEasy" version="1.18.0" targetFramework="net45" />
   <package id="FluentAssertions" version="2.2.0.0" targetFramework="net45" />
   <package id="Moq" version="4.2.1312.1622" targetFramework="net40" />
   <package id="Newtonsoft.Json" version="6.0.1" targetFramework="net45" />

From e2daa0c404f18fd0a012ca062832f64d735e04dc Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 14:49:02 +0200
Subject: [PATCH 19/20] fixed some tests that we're failing in .NET 4.0 but not
 .NET 4.5, switched test projects back to 4.0 because that is what the build
 uses and is a buggier (Uri wise) .net version

---
 .../CodeGeneration.LowLevelClient.csproj             |  3 ++-
 .../CodeGeneration.YamlTestsRunner.csproj            |  3 ++-
 .../Elasticsearch.Net.Connection.Thrift.csproj       |  3 ++-
 src/Nest/Nest.csproj                                 |  3 ++-
 .../Profiling.Indexing/Profiling.Indexing.csproj     |  3 ++-
 .../Elasticsearch.Net.JsonNet.csproj                 |  3 ++-
 .../Elasticsearch.Net.Integration.Yaml.csproj        |  6 ++++--
 .../Elasticsearch.Net.Tests.Unit.csproj              |  3 ++-
 .../Nest.Tests.MockData/Nest.Tests.MockData.csproj   |  7 ++++---
 src/Tests/Nest.Tests.MockData/app.config             |  2 +-
 src/Tests/Nest.Tests.MockData/packages.config        |  2 +-
 .../Core/Validate/ValidateRequestTests.cs            |  5 ++++-
 src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj     | 12 +++++++-----
 .../Search/SearchOptions/SearchOptionTests.cs        |  8 ++++++--
 src/Tests/Nest.Tests.Unit/app.config                 |  2 +-
 src/Tests/Nest.Tests.Unit/packages.config            |  4 ++--
 16 files changed, 44 insertions(+), 25 deletions(-)

diff --git a/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.csproj b/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.csproj
index b12c74ff504..156731f93fe 100644
--- a/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.csproj
+++ b/src/CodeGeneration/CodeGeneration.LowLevelClient/CodeGeneration.LowLevelClient.csproj
@@ -47,7 +47,8 @@
     <Reference Include="CsQuery">
       <HintPath>..\..\..\dep\CsQuery.1.3.4\lib\net40\CsQuery.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json">
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="ShellProgressBar">
diff --git a/src/CodeGeneration/CodeGeneration.YamlTestsRunner/CodeGeneration.YamlTestsRunner.csproj b/src/CodeGeneration/CodeGeneration.YamlTestsRunner/CodeGeneration.YamlTestsRunner.csproj
index 8d7ca1eaf63..9c61d2b5620 100644
--- a/src/CodeGeneration/CodeGeneration.YamlTestsRunner/CodeGeneration.YamlTestsRunner.csproj
+++ b/src/CodeGeneration/CodeGeneration.YamlTestsRunner/CodeGeneration.YamlTestsRunner.csproj
@@ -45,7 +45,8 @@
     <Reference Include="Moq">
       <HintPath>..\..\..\dep\Moq.4.2.1312.1622\lib\net40\Moq.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json">
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="ShellProgressBar">
diff --git a/src/Connections/Elasticsearch.Net.Connection.Thrift/Elasticsearch.Net.Connection.Thrift.csproj b/src/Connections/Elasticsearch.Net.Connection.Thrift/Elasticsearch.Net.Connection.Thrift.csproj
index 2db5acb1acc..bedf35ad5d9 100644
--- a/src/Connections/Elasticsearch.Net.Connection.Thrift/Elasticsearch.Net.Connection.Thrift.csproj
+++ b/src/Connections/Elasticsearch.Net.Connection.Thrift/Elasticsearch.Net.Connection.Thrift.csproj
@@ -69,7 +69,8 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\NetReflector.1.1.2009\lib\net20\NetReflector.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json">
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net40\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="System" />
diff --git a/src/Nest/Nest.csproj b/src/Nest/Nest.csproj
index 8f4e13c884e..a580d139cb9 100644
--- a/src/Nest/Nest.csproj
+++ b/src/Nest/Nest.csproj
@@ -75,7 +75,8 @@
   </PropertyGroup>
   <ItemGroup>
     <Reference Include="Microsoft.CSharp" />
-    <Reference Include="Newtonsoft.Json">
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\dep\Newtonsoft.Json.6.0.1\lib\net40\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="PUrify">
diff --git a/src/Profiling/Profiling.Indexing/Profiling.Indexing.csproj b/src/Profiling/Profiling.Indexing/Profiling.Indexing.csproj
index 0fbf217aa0b..a4a6071c6e6 100644
--- a/src/Profiling/Profiling.Indexing/Profiling.Indexing.csproj
+++ b/src/Profiling/Profiling.Indexing/Profiling.Indexing.csproj
@@ -67,7 +67,8 @@
     <StartupObject>Profiling.Indexing.Program</StartupObject>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Newtonsoft.Json">
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="ServiceStack.Text">
diff --git a/src/Serialization/Elasticsearch.Net.JsonNET/Elasticsearch.Net.JsonNet.csproj b/src/Serialization/Elasticsearch.Net.JsonNET/Elasticsearch.Net.JsonNet.csproj
index f66ec7c773b..d47d409fce8 100644
--- a/src/Serialization/Elasticsearch.Net.JsonNET/Elasticsearch.Net.JsonNet.csproj
+++ b/src/Serialization/Elasticsearch.Net.JsonNET/Elasticsearch.Net.JsonNet.csproj
@@ -30,7 +30,8 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Newtonsoft.Json">
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="System" />
diff --git a/src/Tests/Elasticsearch.Net.Integration.Yaml/Elasticsearch.Net.Integration.Yaml.csproj b/src/Tests/Elasticsearch.Net.Integration.Yaml/Elasticsearch.Net.Integration.Yaml.csproj
index 9d9fc42b517..e8ef6c02e61 100644
--- a/src/Tests/Elasticsearch.Net.Integration.Yaml/Elasticsearch.Net.Integration.Yaml.csproj
+++ b/src/Tests/Elasticsearch.Net.Integration.Yaml/Elasticsearch.Net.Integration.Yaml.csproj
@@ -30,11 +30,13 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="FluentAssertions">
+    <Reference Include="FluentAssertions, Version=2.2.0.0, Culture=neutral, PublicKeyToken=33f2691a05b67b6a, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\FluentAssertions.2.2.0.0\lib\net45\FluentAssertions.dll</HintPath>
     </Reference>
     <Reference Include="Microsoft.CSharp" />
-    <Reference Include="Newtonsoft.Json">
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="nunit.framework, Version=2.6.3.13283, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Elasticsearch.Net.Tests.Unit.csproj b/src/Tests/Elasticsearch.Net.Tests.Unit/Elasticsearch.Net.Tests.Unit.csproj
index 0e972379680..7830fb40a0f 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Elasticsearch.Net.Tests.Unit.csproj
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Elasticsearch.Net.Tests.Unit.csproj
@@ -42,7 +42,8 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\FakeItEasy.1.18.0\lib\net40\FakeItEasy.dll</HintPath>
     </Reference>
-    <Reference Include="FluentAssertions">
+    <Reference Include="FluentAssertions, Version=2.2.0.0, Culture=neutral, PublicKeyToken=33f2691a05b67b6a, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\FluentAssertions.2.2.0.0\lib\net45\FluentAssertions.dll</HintPath>
     </Reference>
     <Reference Include="nunit.framework, Version=2.6.3.13283, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
diff --git a/src/Tests/Nest.Tests.MockData/Nest.Tests.MockData.csproj b/src/Tests/Nest.Tests.MockData/Nest.Tests.MockData.csproj
index af1a7082413..0a832d08d80 100644
--- a/src/Tests/Nest.Tests.MockData/Nest.Tests.MockData.csproj
+++ b/src/Tests/Nest.Tests.MockData/Nest.Tests.MockData.csproj
@@ -13,7 +13,7 @@
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
@@ -67,8 +67,9 @@
     <Reference Include="AutoPoco">
       <HintPath>..\..\..\dep\AutoPoco.1.0.0.0\lib\AutoPoco.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json">
-      <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net40\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="nunit.framework, Version=2.6.3.13283, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
       <HintPath>..\..\..\dep\NUnit.2.6.3\lib\nunit.framework.dll</HintPath>
diff --git a/src/Tests/Nest.Tests.MockData/app.config b/src/Tests/Nest.Tests.MockData/app.config
index 04620c92a58..2fa98702c9d 100644
--- a/src/Tests/Nest.Tests.MockData/app.config
+++ b/src/Tests/Nest.Tests.MockData/app.config
@@ -21,4 +21,4 @@
             </setting>
         </Nest.Tests.MockData.TestData>
     </userSettings>
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"/></startup></configuration>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup></configuration>
diff --git a/src/Tests/Nest.Tests.MockData/packages.config b/src/Tests/Nest.Tests.MockData/packages.config
index 5b685f75ff1..6a2d9924ef6 100644
--- a/src/Tests/Nest.Tests.MockData/packages.config
+++ b/src/Tests/Nest.Tests.MockData/packages.config
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="AutoPoco" version="1.0.0.0" targetFramework="net40" />
-  <package id="Newtonsoft.Json" version="6.0.1" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="6.0.1" targetFramework="net40" />
   <package id="NUnit" version="2.6.3" targetFramework="net45" />
 </packages>
\ No newline at end of file
diff --git a/src/Tests/Nest.Tests.Unit/Core/Validate/ValidateRequestTests.cs b/src/Tests/Nest.Tests.Unit/Core/Validate/ValidateRequestTests.cs
index deeca57e72d..0f8b6ce9e57 100644
--- a/src/Tests/Nest.Tests.Unit/Core/Validate/ValidateRequestTests.cs
+++ b/src/Tests/Nest.Tests.Unit/Core/Validate/ValidateRequestTests.cs
@@ -100,7 +100,10 @@ public void InferredForceQueryString()
 			var status = result.ConnectionStatus;
 			var uri = new Uri(status.RequestUrl);
 			Assert.AreEqual("/nest_test_data/elasticsearchprojects/_validate/query", uri.AbsolutePath);
-			Assert.AreEqual("?source=%7B%20match_all%20:%20%7B%7D%20%7D", uri.Query);
+
+			//normalize difference between .NET 4.5 and prior
+			var query = uri.Query.Replace("%3A", ":");
+			Assert.AreEqual("?source=%7B%20match_all%20:%20%7B%7D%20%7D", query);
 			StringAssert.AreEqualIgnoringCase("GET", status.RequestMethod);
 		}
 	}
diff --git a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
index 1239891f5cf..00955c48a34 100644
--- a/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
+++ b/src/Tests/Nest.Tests.Unit/Nest.Tests.Unit.csproj
@@ -13,7 +13,7 @@
     <FileAlignment>512</FileAlignment>
     <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
     <RestorePackages>true</RestorePackages>
-    <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <TargetFrameworkProfile />
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|AnyCPU'">
@@ -75,14 +75,16 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\dep\FakeItEasy.1.18.0\lib\net40\FakeItEasy.dll</HintPath>
     </Reference>
-    <Reference Include="FluentAssertions">
-      <HintPath>..\..\..\dep\FluentAssertions.2.2.0.0\lib\net45\FluentAssertions.dll</HintPath>
+    <Reference Include="FluentAssertions, Version=2.2.0.0, Culture=neutral, PublicKeyToken=33f2691a05b67b6a, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\dep\FluentAssertions.2.2.0.0\lib\net40\FluentAssertions.dll</HintPath>
     </Reference>
     <Reference Include="Moq">
       <HintPath>..\..\..\dep\Moq.4.2.1312.1622\lib\net40\Moq.dll</HintPath>
     </Reference>
-    <Reference Include="Newtonsoft.Json">
-      <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net45\Newtonsoft.Json.dll</HintPath>
+    <Reference Include="Newtonsoft.Json, Version=6.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\dep\Newtonsoft.Json.6.0.1\lib\net40\Newtonsoft.Json.dll</HintPath>
     </Reference>
     <Reference Include="nunit.framework, Version=2.6.3.13283, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
       <HintPath>..\..\..\dep\NUnit.2.6.3\lib\nunit.framework.dll</HintPath>
diff --git a/src/Tests/Nest.Tests.Unit/Search/SearchOptions/SearchOptionTests.cs b/src/Tests/Nest.Tests.Unit/Search/SearchOptions/SearchOptionTests.cs
index be3b0e0a899..b79113fd0f0 100644
--- a/src/Tests/Nest.Tests.Unit/Search/SearchOptions/SearchOptionTests.cs
+++ b/src/Tests/Nest.Tests.Unit/Search/SearchOptions/SearchOptionTests.cs
@@ -117,7 +117,9 @@ public void TestExecuteOnNode()
 				.Size(10)
 				.ExecuteOnNode("somenode");
 			var result = this._client.Search<ElasticsearchProject>(ss=>s);
-			StringAssert.Contains("preference=_only_node:somenode", result.ConnectionStatus.RequestUrl);
+			//normalize difference between .NET 4.5 and prior
+			var url = result.ConnectionStatus.RequestUrl.Replace("%3A", ":");
+			StringAssert.Contains("preference=_only_node:somenode", url);
 		}
 		[Test]
 		public void TestExecuteOnPreferredNode()
@@ -127,7 +129,9 @@ public void TestExecuteOnPreferredNode()
 				.Size(10)
 				.ExecuteOnPreferredNode("somenode");
 			var result = this._client.Search<ElasticsearchProject>(ss=>s);
-			StringAssert.Contains("preference=_prefer_node:somenode", result.ConnectionStatus.RequestUrl);
+			//normalize difference between .NET 4.5 and prior
+			var url = result.ConnectionStatus.RequestUrl.Replace("%3A", ":");
+			StringAssert.Contains("preference=_prefer_node:somenode", url);
 		}
 		[Test]
 		public void TestFields()
diff --git a/src/Tests/Nest.Tests.Unit/app.config b/src/Tests/Nest.Tests.Unit/app.config
index 8cb2ea39b1c..22ed9de871c 100644
--- a/src/Tests/Nest.Tests.Unit/app.config
+++ b/src/Tests/Nest.Tests.Unit/app.config
@@ -5,7 +5,7 @@
         <section name="Nest.Tests.Unit.Test" type="System.Configuration.ClientSettingsSection, System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" allowExeDefinition="MachineToLocalUser" requirePermission="false"/>
     </sectionGroup>
 </configSections>
-<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5"/></startup><userSettings>
+<startup><supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.0"/></startup><userSettings>
         <Nest.Tests.Unit.Test>
             <setting name="Port" serializeAs="String">
                 <value>9200</value>
diff --git a/src/Tests/Nest.Tests.Unit/packages.config b/src/Tests/Nest.Tests.Unit/packages.config
index cb820f05364..18ccb229ef7 100644
--- a/src/Tests/Nest.Tests.Unit/packages.config
+++ b/src/Tests/Nest.Tests.Unit/packages.config
@@ -2,8 +2,8 @@
 <packages>
   <package id="AutoPoco" version="1.0.0.0" targetFramework="net40" />
   <package id="FakeItEasy" version="1.18.0" targetFramework="net45" />
-  <package id="FluentAssertions" version="2.2.0.0" targetFramework="net45" />
+  <package id="FluentAssertions" version="2.2.0.0" targetFramework="net40" />
   <package id="Moq" version="4.2.1312.1622" targetFramework="net40" />
-  <package id="Newtonsoft.Json" version="6.0.1" targetFramework="net45" />
+  <package id="Newtonsoft.Json" version="6.0.1" targetFramework="net40" />
   <package id="NUnit" version="2.6.3" targetFramework="net45" />
 </packages>
\ No newline at end of file

From 257fa6ad105c4c3a102e848821b970e930e46303 Mon Sep 17 00:00:00 2001
From: Martijn Laarman <Mpdreamz@gmail.com>
Date: Tue, 1 Apr 2014 14:54:35 +0200
Subject: [PATCH 20/20] fixed a tests difference between .NET 3.5 and up

---
 .../Stubs/FakeCalls.cs                          | 17 ++++++++++++++---
 1 file changed, 14 insertions(+), 3 deletions(-)

diff --git a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
index b07e4562581..0f12aada3c8 100644
--- a/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
+++ b/src/Tests/Elasticsearch.Net.Tests.Unit/Stubs/FakeCalls.cs
@@ -31,12 +31,15 @@ public static IReturnValueArgumentValidationConfiguration<Task<ElasticsearchResp
 		public static IReturnValueConfiguration<ElasticsearchResponse<Stream>> PingAtConnectionLevel(AutoFake fake)
 		{
 			return A.CallTo(() => fake.Resolve<IConnection>().HeadSync(
-				A<Uri>.That.Matches(u=>u.AbsolutePath == "/"), A<RequestConnectionConfiguration>._));
+				A<Uri>.That.Matches(IsRoot()), A<RequestConnectionConfiguration>._));
 		}
+
+		
+
 		public static IReturnValueConfiguration<Task<ElasticsearchResponse<Stream>>> PingAtConnectionLevelAsync(AutoFake fake)
 		{
 			return A.CallTo(() => fake.Resolve<IConnection>().Head(
-				A<Uri>.That.Matches(u=>u.AbsolutePath == "/"), A<RequestConnectionConfiguration>._));
+				A<Uri>.That.Matches(IsRoot()), A<RequestConnectionConfiguration>._));
 		}
 		
 		public static IReturnValueConfiguration<ElasticsearchResponse<Stream>> Sniff(
@@ -63,7 +66,15 @@ private static Expression<Func<Uri, bool>> IsSniffUrl()
 		{
 			return u=>u.AbsolutePath.StartsWith("/_nodes/_all");
 		}
-
+		
+		/// <summary>
+		/// AbsolutePath == "" on .NET 3.5 but "/" thereafter.
+		/// </summary>
+		/// <returns></returns>
+		private static Expression<Func<Uri, bool>> IsRoot()
+		{
+			return u=>u.AbsolutePath == "/" || u.AbsolutePath == "";
+		}
 		public static IReturnValueConfiguration<Task<ElasticsearchResponse<Stream>>> SniffAsync(
 			AutoFake fake, 
 			IConnectionConfigurationValues configurationValues = null,